Overleaf/services/web/test/unit/src/Project/ProjectDeleterTests.js

const modulePath = '../../../../app/src/Features/Project/ProjectDeleter'
const SandboxedModule = require('sandboxed-module')
const sinon = require('sinon')
const { expect } = require('chai')
const tk = require('timekeeper')
const moment = require('moment')
const { Project } = require('../helpers/models/Project')
const { DeletedProject } = require('../helpers/models/DeletedProject')
const { ObjectId, ReadPreference } = require('mongodb-legacy')
const Errors = require('../../../../app/src/Features/Errors/Errors')

describe('ProjectDeleter', function () {
  beforeEach(function () {
    tk.freeze(Date.now())
    this.ip = '192.170.18.1'
    this.project = dummyProject()
    this.user = {
      _id: '588f3ddae8ebc1bac07c9fa4',
      first_name: 'bjkdsjfk',
      features: {},
    }

    this.doc = {
      _id: '5bd975f54f62e803cb8a8fec',
      lines: ['a bunch of lines', 'for a sunny day', 'in London town'],
      ranges: {},
      project_id: '5cf9270b4eff6e186cf8b05e',
    }

    this.deletedProjects = [
      {
        _id: '5cf7f145c1401f0ca0eb1aaa',
        deleterData: {
          _id: '5cf7f145c1401f0ca0eb1aac',
          deletedAt: moment().subtract(95, 'days').toDate(),
          deleterId: '588f3ddae8ebc1bac07c9fa4',
          deleterIpAddress: '172.19.0.1',
          deletedProjectId: '5cf9270b4eff6e186cf8b05e',
        },
        project: {
          _id: '5cf9270b4eff6e186cf8b05e',
          overleaf: {
            history: {
              id: new ObjectId(),
            },
          },
        },
      },
      {
        _id: '5cf8eb11c1401f0ca0eb1ad7',
        deleterData: {
          _id: '5b74360c0fbe57011ae9938f',
          deletedAt: moment().subtract(95, 'days').toDate(),
          deleterId: '588f3ddae8ebc1bac07c9fa4',
          deleterIpAddress: '172.20.0.1',
          deletedProjectId: '5cf8f95a0c87371362c23919',
        },
        project: {
          _id: '5cf8f95a0c87371362c23919',
        },
      },
    ]

    this.DocumentUpdaterHandler = {
      promises: {
        flushProjectToMongoAndDelete: sinon.stub().resolves(),
      },
    }
    this.EditorRealTimeController = {
      emitToRoom: sinon.stub(),
    }
    this.TagsHandler = {
      promises: {
        removeProjectFromAllTags: sinon.stub().resolves(),
      },
    }
    this.CollaboratorsHandler = {
      promises: {
        removeUserFromAllProjects: sinon.stub().resolves(),
      },
    }
    this.CollaboratorsGetter = {
      promises: {
        getMemberIds: sinon
          .stub()
          .withArgs(this.project._id)
          .resolves(['member-id-1', 'member-id-2']),
      },
    }

    this.ProjectDetailsHandler = {
      promises: {
        generateUniqueName: sinon.stub().resolves(this.project.name),
      },
    }

    this.ProjectHelper = {
      calculateArchivedArray: sinon.stub(),
    }

    this.db = {
      deletedFiles: {
        indexExists: sinon.stub().resolves(false),
        deleteMany: sinon.stub(),
      },
      projects: {
        insertOne: sinon.stub().resolves(),
      },
    }

    this.DocstoreManager = {
      promises: {
        archiveProject: sinon.stub().resolves(),
        destroyProject: sinon.stub().resolves(),
      },
    }
    this.HistoryManager = {
      promises: {
        deleteProject: sinon.stub().resolves(),
      },
    }

    this.ProjectMock = sinon.mock(Project)
    this.DeletedProjectMock = sinon.mock(DeletedProject)
    this.FileStoreHandler = {
      promises: {
        deleteProject: sinon.stub().resolves(),
      },
    }
    this.Features = {
      hasFeature: sinon.stub().returns(true),
    }
    this.ChatApiHandler = {
      promises: {
        destroyProject: sinon.stub().resolves(),
      },
    }
    this.ProjectAuditLogEntry = {
      deleteMany: sinon.stub().returns({ exec: sinon.stub().resolves() }),
    }
    this.ProjectDeleter = SandboxedModule.require(modulePath, {
      requires: {
        '../../infrastructure/Modules': {
          promises: { hooks: { fire: sinon.stub().resolves() } },
        },
        '../../infrastructure/Features': this.Features,
        '../Editor/EditorRealTimeController': this.EditorRealTimeController,
        '../../models/Project': { Project },
        './ProjectHelper': this.ProjectHelper,
        '../../models/DeletedProject': { DeletedProject },
        '../DocumentUpdater/DocumentUpdaterHandler':
          this.DocumentUpdaterHandler,
        '../Tags/TagsHandler': this.TagsHandler,
        '../FileStore/FileStoreHandler': this.FileStoreHandler,
        '../Chat/ChatApiHandler': this.ChatApiHandler,
        '../Collaborators/CollaboratorsHandler': this.CollaboratorsHandler,
        '../Collaborators/CollaboratorsGetter': this.CollaboratorsGetter,
        '../Docstore/DocstoreManager': this.DocstoreManager,
        './ProjectDetailsHandler': this.ProjectDetailsHandler,
        '../../infrastructure/mongodb': {
          db: this.db,
          ObjectId,
          READ_PREFERENCE_SECONDARY: ReadPreference.secondaryPreferred.mode,
        },
        '../History/HistoryManager': this.HistoryManager,
        '../../models/ProjectAuditLogEntry': {
          ProjectAuditLogEntry: this.ProjectAuditLogEntry,
        },
      },
    })
  })

  afterEach(function () {
    tk.reset()
    this.DeletedProjectMock.restore()
    this.ProjectMock.restore()
  })

  describe('mark as deleted by external source', function () {
    beforeEach(function () {
      this.ProjectMock.expects('updateOne')
        .withArgs(
          { _id: this.project._id },
          { deletedByExternalDataSource: true }
        )
        .chain('exec')
        .resolves()
    })

    it('should update the project with the flag set to true', async function () {
      await this.ProjectDeleter.promises.markAsDeletedByExternalSource(
        this.project._id
      )
      this.ProjectMock.verify()
    })

    it('should tell the editor controler so users are notified', async function () {
      await this.ProjectDeleter.promises.markAsDeletedByExternalSource(
        this.project._id
      )
      expect(this.EditorRealTimeController.emitToRoom).to.have.been.calledWith(
        this.project._id,
        'projectRenamedOrDeletedByExternalSource'
      )
    })
  })

  describe('unmarkAsDeletedByExternalSource', function () {
    beforeEach(async function () {
      this.ProjectMock.expects('updateOne')
        .withArgs(
          { _id: this.project._id },
          { deletedByExternalDataSource: false }
        )
        .chain('exec')
        .resolves()
      await this.ProjectDeleter.promises.unmarkAsDeletedByExternalSource(
        this.project._id
      )
    })

    it('should remove the flag from the project', function () {
      this.ProjectMock.verify()
    })
  })

  describe('deleteUsersProjects', function () {
    beforeEach(function () {
      this.projects = [dummyProject(), dummyProject()]
      this.ProjectMock.expects('find')
        .withArgs({ owner_ref: this.user._id })
        .chain('exec')
        .resolves(this.projects)
      for (const project of this.projects) {
        this.ProjectMock.expects('findOne')
          .withArgs({ _id: project._id })
          .chain('exec')
          .resolves(project)
        this.ProjectMock.expects('deleteOne')
          .withArgs({ _id: project._id })
          .chain('exec')
          .resolves()
        this.DeletedProjectMock.expects('updateOne')
          .withArgs(
            { 'deleterData.deletedProjectId': project._id },
            {
              project,
              deleterData: sinon.match.object,
            },
            { upsert: true }
          )
          .resolves()
      }
    })

    it('should delete all projects owned by the user', async function () {
      await this.ProjectDeleter.promises.deleteUsersProjects(this.user._id)
      this.ProjectMock.verify()
      this.DeletedProjectMock.verify()
    })

    it('should remove any collaboration from this user', async function () {
      await this.ProjectDeleter.promises.deleteUsersProjects(this.user._id)
      sinon.assert.calledWith(
        this.CollaboratorsHandler.promises.removeUserFromAllProjects,
        this.user._id
      )
      sinon.assert.calledOnce(
        this.CollaboratorsHandler.promises.removeUserFromAllProjects
      )
    })
  })

  describe('deleteProject', function () {
    beforeEach(function () {
      this.deleterData = {
        deletedAt: new Date(),
        deletedProjectId: this.project._id,
        deletedProjectOwnerId: this.project.owner_ref,
        deletedProjectCollaboratorIds: this.project.collaberator_refs,
        deletedProjectReadOnlyIds: this.project.readOnly_refs,
        deletedProjectReadWriteTokenAccessIds:
          this.project.tokenAccessReadAndWrite_refs,
        deletedProjectReadOnlyTokenAccessIds:
          this.project.tokenAccessReadOnly_refs,
        deletedProjectReadWriteToken: this.project.tokens.readAndWrite,
        deletedProjectReadOnlyToken: this.project.tokens.readOnly,
        deletedProjectOverleafId: this.project.overleaf.id,
        deletedProjectOverleafHistoryId: this.project.overleaf.history.id,
        deletedProjectLastUpdatedAt: this.project.lastUpdated,
      }

      this.ProjectMock.expects('findOne')
        .withArgs({ _id: this.project._id })
        .chain('exec')
        .resolves(this.project)
    })

    it('should save a DeletedProject with additional deleterData', async function () {
      this.deleterData.deleterIpAddress = this.ip
      this.deleterData.deleterId = this.user._id

      this.ProjectMock.expects('deleteOne').chain('exec').resolves()
      this.DeletedProjectMock.expects('updateOne')
        .withArgs(
          { 'deleterData.deletedProjectId': this.project._id },
          {
            project: this.project,
            deleterData: this.deleterData,
          },
          { upsert: true }
        )
        .resolves()

      await this.ProjectDeleter.promises.deleteProject(this.project._id, {
        deleterUser: this.user,
        ipAddress: this.ip,
      })
      this.DeletedProjectMock.verify()
    })

    it('should flushProjectToMongoAndDelete in doc updater', async function () {
      this.ProjectMock.expects('deleteOne').chain('exec').resolves()
      this.DeletedProjectMock.expects('updateOne').resolves()

      await this.ProjectDeleter.promises.deleteProject(this.project._id, {
        deleterUser: this.user,
        ipAddress: this.ip,
      })
      this.DocumentUpdaterHandler.promises.flushProjectToMongoAndDelete
        .calledWith(this.project._id)
        .should.equal(true)
    })

    it('should flush docs out of mongo', async function () {
      this.ProjectMock.expects('deleteOne').chain('exec').resolves()
      this.DeletedProjectMock.expects('updateOne').resolves()
      await this.ProjectDeleter.promises.deleteProject(this.project._id, {
        deleterUser: this.user,
        ipAddress: this.ip,
      })
      expect(
        this.DocstoreManager.promises.archiveProject
      ).to.have.been.calledWith(this.project._id)
    })

    it('should flush docs out of mongo and ignore errors', async function () {
      this.ProjectMock.expects('deleteOne').chain('exec').resolves()
      this.DeletedProjectMock.expects('updateOne').resolves()
      this.DocstoreManager.promises.archiveProject.rejects(new Error('foo'))
      await this.ProjectDeleter.promises.deleteProject(this.project._id, {
        deleterUser: this.user,
        ipAddress: this.ip,
      })
    })

    it('should removeProjectFromAllTags', async function () {
      this.ProjectMock.expects('deleteOne').chain('exec').resolves()
      this.DeletedProjectMock.expects('updateOne').resolves()

      await this.ProjectDeleter.promises.deleteProject(this.project._id)
      sinon.assert.calledWith(
        this.TagsHandler.promises.removeProjectFromAllTags,
        'member-id-1',
        this.project._id
      )
      sinon.assert.calledWith(
        this.TagsHandler.promises.removeProjectFromAllTags,
        'member-id-2',
        this.project._id
      )
    })

    it('should remove the project from Mongo', async function () {
      this.ProjectMock.expects('deleteOne')
        .withArgs({ _id: this.project._id })
        .chain('exec')
        .resolves()
      this.DeletedProjectMock.expects('updateOne').resolves()

      await this.ProjectDeleter.promises.deleteProject(this.project._id)
      this.ProjectMock.verify()
    })
  })

  describe('expireDeletedProjectsAfterDuration', function () {
    beforeEach(async function () {
      for (const deletedProject of this.deletedProjects) {
        this.ProjectMock.expects('findById')
          .withArgs(deletedProject.deleterData.deletedProjectId)
          .chain('exec')
          .resolves(null)
      }
      this.DeletedProjectMock.expects('find')
        .withArgs({
          'deleterData.deletedAt': {
            $lt: new Date(moment().subtract(90, 'days')),
          },
          project: {
            $type: 'object',
          },
        })
        .chain('exec')
        .resolves(this.deletedProjects)

      for (const deletedProject of this.deletedProjects) {
        this.DeletedProjectMock.expects('findOne')
          .withArgs({
            'deleterData.deletedProjectId': deletedProject.project._id,
          })
          .chain('exec')
          .resolves(deletedProject)
        this.DeletedProjectMock.expects('updateOne')
          .withArgs(
            {
              _id: deletedProject._id,
            },
            {
              $set: {
                'deleterData.deleterIpAddress': null,
                project: null,
              },
            }
          )
          .chain('exec')
          .resolves()
      }

      await this.ProjectDeleter.promises.expireDeletedProjectsAfterDuration()
    })

    it('should expire projects older than 90 days', function () {
      this.DeletedProjectMock.verify()
    })
  })

  describe('expireDeletedProject', function () {
    describe('on an inactive project', function () {
      beforeEach(async function () {
        this.ProjectMock.expects('findById')
          .withArgs(this.deletedProjects[0].deleterData.deletedProjectId)
          .chain('exec')
          .resolves(null)
        this.DeletedProjectMock.expects('updateOne')
          .withArgs(
            {
              _id: this.deletedProjects[0]._id,
            },
            {
              $set: {
                'deleterData.deleterIpAddress': null,
                project: null,
              },
            }
          )
          .chain('exec')
          .resolves()

        this.DeletedProjectMock.expects('findOne')
          .withArgs({
            'deleterData.deletedProjectId': this.deletedProjects[0].project._id,
          })
          .chain('exec')
          .resolves(this.deletedProjects[0])

        await this.ProjectDeleter.promises.expireDeletedProject(
          this.deletedProjects[0].project._id
        )
      })

      it('should find the specified deletedProject and remove its project and ip address', function () {
        this.DeletedProjectMock.verify()
      })

      it('should destroy the docs in docstore', function () {
        expect(
          this.DocstoreManager.promises.destroyProject
        ).to.have.been.calledWith(this.deletedProjects[0].project._id)
      })

      it('should delete the project in history', function () {
        expect(
          this.HistoryManager.promises.deleteProject
        ).to.have.been.calledWith(
          this.deletedProjects[0].project._id,
          this.deletedProjects[0].project.overleaf.history.id
        )
      })

      it('should destroy the files in filestore', function () {
        expect(
          this.FileStoreHandler.promises.deleteProject
        ).to.have.been.calledWith(this.deletedProjects[0].project._id)
      })

      it('should destroy the chat threads and messages', function () {
        expect(
          this.ChatApiHandler.promises.destroyProject
        ).to.have.been.calledWith(this.deletedProjects[0].project._id)
      })

      it('should delete audit logs', async function () {
        expect(this.ProjectAuditLogEntry.deleteMany).to.have.been.calledWith({
          projectId: this.deletedProjects[0].project._id,
        })
      })
    })

    describe('on an active project (from an incomplete delete)', function () {
      beforeEach(async function () {
        this.ProjectMock.expects('findById')
          .withArgs(this.deletedProjects[0].deleterData.deletedProjectId)
          .chain('exec')
          .resolves(this.deletedProjects[0].project)
        this.DeletedProjectMock.expects('deleteOne')
          .withArgs({
            'deleterData.deletedProjectId': this.deletedProjects[0].project._id,
          })
          .chain('exec')
          .resolves()
        await this.ProjectDeleter.promises.expireDeletedProject(
          this.deletedProjects[0].project._id
        )
      })

      it('should delete the spurious deleted project record', function () {
        this.DeletedProjectMock.verify()
      })

      it('should not destroy the docs in docstore', function () {
        expect(this.DocstoreManager.promises.destroyProject).to.not.have.been
          .called
      })

      it('should not delete the project in history', function () {
        expect(this.HistoryManager.promises.deleteProject).to.not.have.been
          .called
      })

      it('should not destroy the files in filestore', function () {
        expect(this.FileStoreHandler.promises.deleteProject).to.not.have.been
          .called
      })

      it('should not destroy the chat threads and messages', function () {
        expect(this.ChatApiHandler.promises.destroyProject).to.not.have.been
          .called
      })
    })
  })

  describe('archiveProject', function () {
    beforeEach(function () {
      const archived = [new ObjectId(this.user._id)]
      this.ProjectHelper.calculateArchivedArray.returns(archived)

      this.ProjectMock.expects('findOne')
        .withArgs({ _id: this.project._id })
        .chain('exec')
        .resolves(this.project)

      this.ProjectMock.expects('updateOne')
        .withArgs(
          { _id: this.project._id },
          {
            $set: { archived },
            $pull: { trashed: new ObjectId(this.user._id) },
          }
        )
        .resolves()
    })

    it('should update the project', async function () {
      await this.ProjectDeleter.promises.archiveProject(
        this.project._id,
        this.user._id
      )
      this.ProjectMock.verify()
    })

    it('calculates the archived array', async function () {
      await this.ProjectDeleter.promises.archiveProject(
        this.project._id,
        this.user._id
      )
      expect(this.ProjectHelper.calculateArchivedArray).to.have.been.calledWith(
        this.project,
        this.user._id,
        'ARCHIVE'
      )
    })
  })

  describe('unarchiveProject', function () {
    beforeEach(function () {
      const archived = [new ObjectId(this.user._id)]
      this.ProjectHelper.calculateArchivedArray.returns(archived)

      this.ProjectMock.expects('findOne')
        .withArgs({ _id: this.project._id })
        .chain('exec')
        .resolves(this.project)

      this.ProjectMock.expects('updateOne')
        .withArgs({ _id: this.project._id }, { $set: { archived } })
        .resolves()
    })

    it('should update the project', async function () {
      await this.ProjectDeleter.promises.unarchiveProject(
        this.project._id,
        this.user._id
      )
      this.ProjectMock.verify()
    })

    it('calculates the archived array', async function () {
      await this.ProjectDeleter.promises.unarchiveProject(
        this.project._id,
        this.user._id
      )
      expect(this.ProjectHelper.calculateArchivedArray).to.have.been.calledWith(
        this.project,
        this.user._id,
        'UNARCHIVE'
      )
    })
  })

  describe('trashProject', function () {
    beforeEach(function () {
      const archived = [new ObjectId(this.user._id)]
      this.ProjectHelper.calculateArchivedArray.returns(archived)

      this.ProjectMock.expects('findOne')
        .withArgs({ _id: this.project._id })
        .chain('exec')
        .resolves(this.project)

      this.ProjectMock.expects('updateOne')
        .withArgs(
          { _id: this.project._id },
          {
            $addToSet: { trashed: new ObjectId(this.user._id) },
            $set: { archived },
          }
        )
        .resolves()
    })

    it('should update the project', async function () {
      await this.ProjectDeleter.promises.trashProject(
        this.project._id,
        this.user._id
      )
      this.ProjectMock.verify()
    })

    it('unarchives the project', async function () {
      await this.ProjectDeleter.promises.trashProject(
        this.project._id,
        this.user._id
      )
      expect(this.ProjectHelper.calculateArchivedArray).to.have.been.calledWith(
        this.project,
        this.user._id,
        'UNARCHIVE'
      )
    })
  })

  describe('untrashProject', function () {
    beforeEach(function () {
      this.ProjectMock.expects('findOne')
        .withArgs({ _id: this.project._id })
        .chain('exec')
        .resolves(this.project)

      this.ProjectMock.expects('updateOne')
        .withArgs(
          { _id: this.project._id },
          { $pull: { trashed: new ObjectId(this.user._id) } }
        )
        .resolves()
    })

    it('should update the project', async function () {
      await this.ProjectDeleter.promises.untrashProject(
        this.project._id,
        this.user._id
      )
      this.ProjectMock.verify()
    })
  })

  describe('restoreProject', function () {
    beforeEach(function () {
      this.ProjectMock.expects('updateOne')
        .withArgs(
          {
            _id: this.project._id,
          },
          {
            $unset: { archived: true },
          }
        )
        .chain('exec')
        .resolves()
    })

    it('should unset the archive attribute', async function () {
      await this.ProjectDeleter.promises.restoreProject(this.project._id)
    })
  })

  describe('undeleteProject', function () {
    beforeEach(function () {
      this.unknownProjectId = new ObjectId()
      this.purgedProjectId = new ObjectId()

      this.deletedProject = {
        _id: 'deleted',
        project: this.project,
        deleterData: {
          deletedProjectId: this.project._id,
          deletedProjectOwnerId: this.project.owner_ref,
        },
      }
      this.purgedProject = {
        _id: 'purged',
        deleterData: {
          deletedProjectId: this.purgedProjectId,
          deletedProjectOwnerId: 'potato',
        },
      }

      this.DeletedProjectMock.expects('findOne')
        .withArgs({ 'deleterData.deletedProjectId': this.project._id })
        .chain('exec')
        .resolves(this.deletedProject)
      this.DeletedProjectMock.expects('findOne')
        .withArgs({ 'deleterData.deletedProjectId': this.purgedProjectId })
        .chain('exec')
        .resolves(this.purgedProject)
      this.DeletedProjectMock.expects('findOne')
        .withArgs({ 'deleterData.deletedProjectId': this.unknownProjectId })
        .chain('exec')
        .resolves(null)
      this.DeletedProjectMock.expects('deleteOne').chain('exec').resolves()
    })

    it('should return not found if the project does not exist', async function () {
      await expect(
        this.ProjectDeleter.promises.undeleteProject(
          this.unknownProjectId.toString()
        )
      ).to.be.rejectedWith(Errors.NotFoundError, 'project_not_found')
    })

    it('should return not found if the project has been expired', async function () {
      await expect(
        this.ProjectDeleter.promises.undeleteProject(
          this.purgedProjectId.toString()
        )
      ).to.be.rejectedWith(Errors.NotFoundError, 'project_too_old_to_restore')
    })

    it('should insert the project into the collection', async function () {
      await this.ProjectDeleter.promises.undeleteProject(this.project._id)
      sinon.assert.calledWith(
        this.db.projects.insertOne,
        sinon.match({
          _id: this.project._id,
          name: this.project.name,
        })
      )
    })

    it('should clear the archive bit', async function () {
      this.project.archived = true
      await this.ProjectDeleter.promises.undeleteProject(this.project._id)
      sinon.assert.calledWith(
        this.db.projects.insertOne,
        sinon.match({ archived: undefined })
      )
    })

    it('should generate a unique name for the project', async function () {
      await this.ProjectDeleter.promises.undeleteProject(this.project._id)
      sinon.assert.calledWith(
        this.ProjectDetailsHandler.promises.generateUniqueName,
        this.project.owner_ref
      )
    })

    it('should add a suffix to the project name', async function () {
      await this.ProjectDeleter.promises.undeleteProject(this.project._id)
      sinon.assert.calledWith(
        this.ProjectDetailsHandler.promises.generateUniqueName,
        this.project.owner_ref,
        this.project.name + ' (Restored)'
      )
    })

    it('should remove the DeletedProject', async function () {
      // need to change the mock just to include the methods we want
      this.DeletedProjectMock.restore()
      this.DeletedProjectMock = sinon.mock(DeletedProject)
      this.DeletedProjectMock.expects('findOne')
        .withArgs({ 'deleterData.deletedProjectId': this.project._id })
        .chain('exec')
        .resolves(this.deletedProject)
      this.DeletedProjectMock.expects('deleteOne')
        .withArgs({ _id: 'deleted' })
        .chain('exec')
        .resolves()

      await this.ProjectDeleter.promises.undeleteProject(this.project._id)
      this.DeletedProjectMock.verify()
    })
  })
})

function dummyProject() {
  return {
    _id: new ObjectId(),
    lastUpdated: new Date(),
    rootFolder: [],
    collaberator_refs: [new ObjectId(), new ObjectId()],
    readOnly_refs: [new ObjectId(), new ObjectId()],
    tokenAccessReadAndWrite_refs: [new ObjectId(), new ObjectId()],
    tokenAccessReadOnly_refs: [new ObjectId(), new ObjectId()],
    owner_ref: new ObjectId(),
    tokens: {
      readOnly: 'wombat',
      readAndWrite: 'potato',
    },
    overleaf: {
      id: 1234,
      history: {
        id: 5678,
      },
    },
    name: 'a very scientific analysis of spooky ghosts',
  }
}