Move document improvements (#927)

* Show all collections in UI

* Introduce command pattern

* Actually remove from previous collection

* Stash

* Fixes: Promises resolved outside of response lifecycle

* 💚

* 💚

* documentMover tests

* Transaction

* Perf. More in transactions

server/commands/documentMover.js

@@ -0,0 +1,83 @@
+// @flow
+import { Document, Collection } from '../models';
+import { sequelize } from '../sequelize';
+
+export default async function documentMover({
+  document,
+  collectionId,
+  parentDocumentId,
+  index,
+}: {
+  document: Document,
+  collectionId: string,
+  parentDocumentId: string,
+  index?: number,
+}) {
+  let transaction;
+  const result = { collections: [], documents: [] };
+  const collectionChanged = collectionId !== document.collectionId;
+
+  try {
+    transaction = await sequelize.transaction();
+
+    // remove from original collection
+    const collection = await document.getCollection({ transaction });
+    const documentJson = await collection.removeDocumentInStructure(document, {
+      save: false,
+    });
+
+    // if the collection is the same then it will get saved below, this
+    // line prevents a pointless intermediate save from occurring.
+    if (collectionChanged) await collection.save({ transaction });
+
+    // add to new collection (may be the same)
+    document.collectionId = collectionId;
+    document.parentDocumentId = parentDocumentId;
+
+    const newCollection: Collection = collectionChanged
+      ? await Collection.findById(collectionId, { transaction })
+      : collection;
+    await newCollection.addDocumentToStructure(document, index, {
+      documentJson,
+    });
+    result.collections.push(collection);
+
+    // if collection does not remain the same loop through children and change their
+    // collectionId too. This includes archived children, otherwise their collection
+    // would be wrong once restored.
+    if (collectionChanged) {
+      result.collections.push(newCollection);
+
+      const loopChildren = async documentId => {
+        const childDocuments = await Document.findAll({
+          where: { parentDocumentId: documentId },
+        });
+
+        await Promise.all(
+          childDocuments.map(async child => {
+            await loopChildren(child.id);
+            await child.update({ collectionId }, { transaction });
+            child.collection = newCollection;
+            result.documents.push(child);
+          })
+        );
+      };
+
+      await loopChildren(document.id);
+    }
+
+    await document.save({ transaction });
+    document.collection = newCollection;
+    result.documents.push(document);
+
+    await transaction.commit();
+  } catch (err) {
+    if (transaction) {
+      await transaction.rollback();
+    }
+    throw err;
+  }
+
+  // we need to send all updated models back to the client
+  return result;
+}

server/commands/documentMover.test.js

@@ -0,0 +1,85 @@
+/* eslint-disable flowtype/require-valid-file-annotation */
+import documentMover from '../commands/documentMover';
+import { flushdb, seed } from '../test/support';
+import { buildDocument, buildCollection } from '../test/factories';
+
+beforeEach(flushdb);
+
+describe('documentMover', async () => {
+  it('should move within a collection', async () => {
+    const { document, collection } = await seed();
+
+    const response = await documentMover({
+      document,
+      collectionId: collection.id,
+    });
+
+    expect(response.collections.length).toEqual(1);
+    expect(response.documents.length).toEqual(1);
+  });
+
+  it('should move with children', async () => {
+    const { document, collection } = await seed();
+    const newDocument = await buildDocument({
+      parentDocumentId: document.id,
+      collectionId: collection.id,
+      teamId: collection.teamId,
+      userId: collection.creatorId,
+      title: 'Child document',
+      text: 'content',
+    });
+    await collection.addDocumentToStructure(newDocument);
+
+    const response = await documentMover({
+      document,
+      collectionId: collection.id,
+      parentDocumentId: undefined,
+      index: 0,
+    });
+
+    expect(response.collections[0].documentStructure[0].children[0].id).toBe(
+      newDocument.id
+    );
+    expect(response.collections.length).toEqual(1);
+    expect(response.documents.length).toEqual(1);
+  });
+
+  it('should move with children to another collection', async () => {
+    const { document, collection } = await seed();
+    const newCollection = await buildCollection({
+      teamId: collection.teamId,
+    });
+    const newDocument = await buildDocument({
+      parentDocumentId: document.id,
+      collectionId: collection.id,
+      teamId: collection.teamId,
+      userId: collection.creatorId,
+      title: 'Child document',
+      text: 'content',
+    });
+    await collection.addDocumentToStructure(newDocument);
+
+    const response = await documentMover({
+      document,
+      collectionId: newCollection.id,
+      parentDocumentId: undefined,
+      index: 0,
+    });
+
+    // check document ids where updated
+    await newDocument.reload();
+    expect(newDocument.collectionId).toBe(newCollection.id);
+
+    await document.reload();
+    expect(document.collectionId).toBe(newCollection.id);
+
+    // check collection structure updated
+    expect(response.collections[0].id).toBe(collection.id);
+    expect(response.collections[1].id).toBe(newCollection.id);
+    expect(response.collections[1].documentStructure[0].children[0].id).toBe(
+      newDocument.id
+    );
+    expect(response.collections.length).toEqual(2);
+    expect(response.documents.length).toEqual(2);
+  });
+});