Version History (#768)

* Stash. Super rough progress

* Stash

* 'h' how toggles history panel
Add documents.restore endpoint

* Add tests for documents.restore endpoint

* Document restore endpoint

* Tiding, RevisionMenu, remove scroll dep

* Add history menu item

* Paginate loading

* Fixed: Error boundary styling
Select first revision faster

* Diff summary, styling

* Add history loading placeholder
Fix move modal not opening

* Fixes: Refreshing page on specific revision

* documentation for document.revision

* Better handle versions with no text changes (will no longer be created)

server/api/__snapshots__/documents.test.js.snap

@@ -35,6 +35,15 @@ Object {
 }
 `;
 
+exports[`#documents.restore should require authentication 1`] = `
+Object {
+  "error": "authentication_required",
+  "message": "Authentication required",
+  "ok": false,
+  "status": 401,
+}
+`;
+
 exports[`#documents.search should require authentication 1`] = `
 Object {
   "error": "authentication_required",

server/api/documents.js

@@ -195,6 +195,26 @@ router.post('documents.info', auth({ required: false }), async ctx => {
   };
 });
 
+router.post('documents.revision', auth(), async ctx => {
+  let { id, revisionId } = ctx.body;
+  ctx.assertPresent(id, 'id is required');
+  ctx.assertPresent(revisionId, 'revisionId is required');
+  const document = await Document.findById(id);
+  authorize(ctx.state.user, 'read', document);
+
+  const revision = await Revision.findOne({
+    where: {
+      id: revisionId,
+      documentId: document.id,
+    },
+  });
+
+  ctx.body = {
+    pagination: ctx.state.pagination,
+    data: presentRevision(ctx, revision),
+  };
+});
+
 router.post('documents.revisions', auth(), pagination(), async ctx => {
   let { id, sort = 'updatedAt', direction } = ctx.body;
   if (direction !== 'ASC') direction = 'DESC';
@@ -211,7 +231,9 @@ router.post('documents.revisions', auth(), pagination(), async ctx => {
   });
 
   const data = await Promise.all(
-    revisions.map(revision => presentRevision(ctx, revision))
+    revisions.map((revision, index) =>
+      presentRevision(ctx, revision, revisions[index + 1])
+    )
   );
 
   ctx.body = {
@@ -220,6 +242,27 @@ router.post('documents.revisions', auth(), pagination(), async ctx => {
   };
 });
 
+router.post('documents.restore', auth(), async ctx => {
+  const { id, revisionId } = ctx.body;
+  ctx.assertPresent(id, 'id is required');
+  ctx.assertPresent(revisionId, 'revisionId is required');
+
+  const user = ctx.state.user;
+  const document = await Document.findById(id);
+  authorize(user, 'update', document);
+
+  const revision = await Revision.findById(revisionId);
+  authorize(document, 'restore', revision);
+
+  document.text = revision.text;
+  document.title = revision.title;
+  await document.save();
+
+  ctx.body = {
+    data: await presentDocument(ctx, document),
+  };
+});
+
 router.post('documents.search', auth(), pagination(), async ctx => {
   const { query } = ctx.body;
   const { offset, limit } = ctx.state.pagination;

server/api/documents.test.js

@@ -418,6 +418,63 @@ describe('#documents.pin', async () => {
   });
 });
 
+describe('#documents.restore', async () => {
+  it('should restore the document to a previous version', async () => {
+    const { user, document } = await seed();
+    const revision = await Revision.findOne({
+      where: { documentId: document.id },
+    });
+    const previousText = revision.text;
+    const revisionId = revision.id;
+
+    // update the document contents
+    document.text = 'UPDATED';
+    await document.save();
+
+    const res = await server.post('/api/documents.restore', {
+      body: { token: user.getJwtToken(), id: document.id, revisionId },
+    });
+    const body = await res.json();
+    expect(body.data.text).toEqual(previousText);
+  });
+
+  it('should not allow restoring a revision in another document', async () => {
+    const { user, document } = await seed();
+    const anotherDoc = await buildDocument();
+    const revision = await Revision.findOne({
+      where: { documentId: anotherDoc.id },
+    });
+    const revisionId = revision.id;
+
+    const res = await server.post('/api/documents.restore', {
+      body: { token: user.getJwtToken(), id: document.id, revisionId },
+    });
+    expect(res.status).toEqual(403);
+  });
+
+  it('should require authentication', async () => {
+    const res = await server.post('/api/documents.restore');
+    const body = await res.json();
+
+    expect(res.status).toEqual(401);
+    expect(body).toMatchSnapshot();
+  });
+
+  it('should require authorization', async () => {
+    const { document } = await seed();
+    const revision = await Revision.findOne({
+      where: { documentId: document.id },
+    });
+    const revisionId = revision.id;
+
+    const user = await buildUser();
+    const res = await server.post('/api/documents.restore', {
+      body: { token: user.getJwtToken(), id: document.id, revisionId },
+    });
+    expect(res.status).toEqual(403);
+  });
+});
+
 describe('#documents.unpin', async () => {
   it('should unpin the document', async () => {
     const { user, document } = await seed();