feat: Update default collection tab (#1821)

* feat: Allow listing root level documents only via documents.list

* feat: New tab on collection home

* update tab layout

* fix: Correctly sort index sorted documents.list

* revert: Tab layout changes

* fix: Missing route for recently published
fix: Redirect unknown tabs

server/api/documents.js

@@ -37,7 +37,7 @@ const { authorize, cannot } = policy;
 const router = new Router();
 
 router.post("documents.list", auth(), pagination(), async (ctx) => {
-  const {
+  let {
     sort = "updatedAt",
     template,
     backlinkDocumentId,
@@ -70,6 +70,7 @@ router.post("documents.list", auth(), pagination(), async (ctx) => {
     where = { ...where, createdById };
   }
 
+  let documentIds = [];
   // if a specific collection is passed then we need to check auth to view it
   if (collectionId) {
     ctx.assertUuid(collectionId, "collection must be a UUID");
@@ -80,6 +81,15 @@ router.post("documents.list", auth(), pagination(), async (ctx) => {
     }).findByPk(collectionId);
     authorize(user, "read", collection);
 
+    // index sort is special because it uses the order of the documents in the
+    // collection.documentStructure rather than a database column
+    if (sort === "index") {
+      documentIds = collection.documentStructure
+        .map((node) => node.id)
+        .slice(ctx.state.pagination.offset, ctx.state.pagination.limit);
+      where = { ...where, id: documentIds };
+    }
+
     // otherwise, filter by all collections the user has access to
   } else {
     const collectionIds = await user.collectionIds();
@@ -91,6 +101,12 @@ router.post("documents.list", auth(), pagination(), async (ctx) => {
     where = { ...where, parentDocumentId };
   }
 
+  // Explicitly passing 'null' as the parentDocumentId allows listing documents
+  // that have no parent document (aka they are at the root of the collection)
+  if (parentDocumentId === null) {
+    where = { ...where, parentDocumentId: { [Op.eq]: null } };
+  }
+
   if (backlinkDocumentId) {
     ctx.assertUuid(backlinkDocumentId, "backlinkDocumentId must be a UUID");
 
@@ -107,6 +123,10 @@ router.post("documents.list", auth(), pagination(), async (ctx) => {
     };
   }
 
+  if (sort === "index") {
+    sort = "updatedAt";
+  }
+
   // add the users starred state to the response by default
   const starredScope = { method: ["withStarred", user.id] };
   const collectionScope = { method: ["withCollection", user.id] };
@@ -123,6 +143,14 @@ router.post("documents.list", auth(), pagination(), async (ctx) => {
     limit: ctx.state.pagination.limit,
   });
 
+  // index sort is special because it uses the order of the documents in the
+  // collection.documentStructure rather than a database column
+  if (documentIds.length) {
+    documents.sort(
+      (a, b) => documentIds.indexOf(a.id) - documentIds.indexOf(b.id)
+    );
+  }
+
   const data = await Promise.all(
     documents.map((document) => presentDocument(document))
   );

server/api/documents.test.js

@@ -433,7 +433,27 @@ describe("#documents.list", () => {
     expect(body.data[0].id).toEqual(document.id);
   });
 
-  it("should not return unpublished documents", async () => {
+  it("should allow filtering documents with no parent", async () => {
+    const { user, document } = await seed();
+    await buildDocument({
+      title: "child document",
+      text: "random text",
+      parentDocumentId: document.id,
+      userId: user.id,
+      teamId: user.teamId,
+    });
+
+    const res = await server.post("/api/documents.list", {
+      body: { token: user.getJwtToken(), parentDocumentId: null },
+    });
+    const body = await res.json();
+
+    expect(res.status).toEqual(200);
+    expect(body.data.length).toEqual(1);
+    expect(body.data[0].id).toEqual(document.id);
+  });
+
+  it("should not return draft documents", async () => {
     const { user, document } = await seed();
     document.publishedAt = null;
     await document.save();
@@ -493,6 +513,32 @@ describe("#documents.list", () => {
     expect(body.data[1].id).toEqual(anotherDoc.id);
   });
 
+  it("should allow sorting by collection index", async () => {
+    const { user, document, collection } = await seed();
+    const anotherDoc = await buildDocument({
+      title: "another document",
+      text: "random text",
+      userId: user.id,
+      teamId: user.teamId,
+      collectionId: collection.id,
+    });
+    await collection.addDocumentToStructure(anotherDoc, 0);
+
+    const res = await server.post("/api/documents.list", {
+      body: {
+        token: user.getJwtToken(),
+        collectionId: collection.id,
+        sort: "index",
+        direction: "ASC",
+      },
+    });
+    const body = await res.json();
+
+    expect(res.status).toEqual(200);
+    expect(body.data[0].id).toEqual(anotherDoc.id);
+    expect(body.data[1].id).toEqual(document.id);
+  });
+
   it("should allow filtering by collection", async () => {
     const { user, document } = await seed();
     const res = await server.post("/api/documents.list", {