apostrophe 3.62.0 → 3.63.0

package/test/job.js

@@ -1,10 +1,11 @@
 const t = require('../test-lib/test.js');
 const assert = require('assert');
 const Promise = require('bluebird');
-let apos;
 
 describe('Job module', function() {
 
+  let apos;
+
   this.timeout(t.timeout);
 
   after(async function() {
@@ -182,43 +183,42 @@ describe('Job module', function() {
     // Tests failure()
     assert(bad === (articleIds.length / 2));
   });
-});
-
-function padInteger (i, places) {
-  let s = i + '';
-  while (s.length < places) {
-    s = '0' + s;
+  function padInteger (i, places) {
+    let s = i + '';
+    while (s.length < places) {
+      s = '0' + s;
+    }
+    return s;
   }
-  return s;
-}
-
-async function insert (req, pieceModule, title, data, i) {
-  const docData = Object.assign(pieceModule.newInstance(), {
-    title: `${title} #${padInteger(i, 5)}`,
-    slug: `${title}-${padInteger(i, 5)}`,
-    ...data
-  });
 
-  return pieceModule.insert(req, docData);
-};
-
-async function pollJob(job, { jar }) {
-  const {
-    processed,
-    total,
-    good,
-    bad
-  } = await apos.http.get(job.route, { jar });
+  async function insert (req, pieceModule, title, data, i) {
+    const docData = Object.assign(pieceModule.newInstance(), {
+      title: `${title} #${padInteger(i, 5)}`,
+      slug: `${title}-${padInteger(i, 5)}`,
+      ...data
+    });
 
-  if (processed < total) {
-    Promise.delay(100);
+    return pieceModule.insert(req, docData);
+  };
 
-    return await pollJob(job, { jar });
-  } else {
-    return {
-      completed: processed,
+  async function pollJob(job, { jar }) {
+    const {
+      processed,
+      total,
       good,
       bad
-    };
+    } = await apos.http.get(job.route, { jar });
+
+    if (processed < total) {
+      Promise.delay(100);
+
+      return await pollJob(job, { jar });
+    } else {
+      return {
+        completed: processed,
+        good,
+        bad
+      };
+    }
   }
-}
+});

package/test/locks.js

@@ -2,10 +2,10 @@ const t = require('../test-lib/test.js');
 const assert = require('assert');
 const Promise = require('bluebird');
 
-let apos;
-
 describe('Locks', function() {
 
+  let apos;
+
   this.timeout(t.timeout);
 
   after(function() {

package/test/login-requirements.js

@@ -1,9 +1,10 @@
 const t = require('../test-lib/test.js');
 const assert = require('assert');
 
-let apos;
-
 describe('Login', function() {
+
+  let apos;
+
   const extraSecretErr = 'extra secret incorrect';
   const captchaErr = 'captcha code incorrect';
 

package/test/middleware-and-route-order.js

@@ -1,10 +1,10 @@
 const t = require('../test-lib/test.js');
 const assert = require('assert');
 
-let apos;
-
 describe('Middleware and Route Order', function() {
 
+  let apos;
+
   this.timeout(t.timeout);
 
   after(async function () {

package/test/page-type.js

@@ -1,9 +1,10 @@
 const t = require('../test-lib/test.js');
 const assert = require('assert');
-let apos;
 
 describe('page-type', function() {
 
+  let apos;
+
   this.timeout(t.timeout);
 
   after(async function() {

package/test/pages-autocomplete.js

@@ -145,17 +145,6 @@ describe('Pages Autocomplete', function() {
       assert.equal(suggestions.results[0].slug, '/complex-page', 'complex page slug not found');
     }
   });
-
-  it('should ignore type when no autocomplete', async function () {
-    const result = await apos.http.get('/api/v1/@apostrophecms/page', {
-      jar,
-      qs: {
-        type: 'test-page'
-      }
-    });
-    assert.equal(result.slug, '/', 'home page not found');
-    assert.equal(result._children.length, 2, 'children result does not match');
-  });
 });
 
 async function login(apos) {

package/test/pages-public-api.js

@@ -1,10 +1,10 @@
 const t = require('../test-lib/test.js');
 const assert = require('assert');
 
-let apos;
-
 describe('Pages Public API', function() {
 
+  let apos;
+
   this.timeout(t.timeout);
 
   after(async function () {

package/test/pages-rest.js

@@ -1,10 +1,6 @@
 const t = require('../test-lib/test.js');
 const assert = require('assert');
 
-let apos;
-let homeId;
-let jar;
-
 const areaConfig = {
   '@apostrophecms/image': {},
   '@apostrophecms/video': {},
@@ -38,6 +34,10 @@ const areaConfig = {
 
 describe('Pages REST', function() {
 
+  let apos;
+  let homeId;
+  let jar;
+
   this.timeout(t.timeout);
 
   after(function() {

package/test/pages.js

@@ -2,21 +2,15 @@ const t = require('../test-lib/test.js');
 const assert = require('assert');
 const _ = require('lodash');
 
-let apos;
-let homeId;
-const apiKey = 'this is a test api key';
-
 describe('Pages', function() {
+  let apos;
+  let home;
+  let homeId;
+  const apiKey = 'this is a test api key';
 
   this.timeout(t.timeout);
 
-  after(function() {
-    return t.destroy(apos);
-  });
-
-  // EXISTENCE
-
-  it('should be a property of the apos object', async function() {
+  before(async function() {
     apos = await t.create({
       root: module,
       modules: {
@@ -54,54 +48,9 @@ describe('Pages', function() {
       }
     });
 
-    assert(apos.page.__meta.name === '@apostrophecms/page');
-  });
-
-  // SETUP
-
-  it('should make sure all of the expected indexes are configured', async function() {
-    const expectedIndexes = [ 'path' ];
-    const actualIndexes = [];
-
-    const info = await apos.doc.db.indexInformation();
-
-    // Extract the actual index info we care about
-    _.each(info, function(index) {
-      actualIndexes.push(index[0][0]);
-    });
-
-    // Now make sure everything in expectedIndexes is in actualIndexes
-    _.each(expectedIndexes, function(index) {
-      assert(_.includes(actualIndexes, index));
-    });
-  });
-
-  it('parked homepage exists', async function() {
-    const home = await apos.page.find(apos.task.getAnonReq(), { level: 0 }).toObject();
-
-    assert(home);
+    home = await apos.page.find(apos.task.getAnonReq(), { level: 0 }).toObject();
     homeId = home._id;
-    assert(home.slug === '/');
-    assert(`${home.path}:en:published` === home._id);
-    assert(home.type === '@apostrophecms/home-page');
-    assert(home.parked);
-    assert(home.visibility === 'public');
-  });
 
-  it('parked archive page exists', async function() {
-    const archive = await apos.page.find(apos.task.getReq(), { slug: '/archive' }).archived(null).toObject();
-    assert(archive);
-    assert(archive.slug === '/archive');
-    assert(archive.path === `${homeId.replace(':en:published', '')}/${archive._id.replace(':en:published', '')}`);
-    assert(archive.type === '@apostrophecms/archive-page');
-    assert(archive.parked);
-    // Verify that clonePermanent did its
-    // job and removed properties not meant
-    // to be stored in mongodb
-    assert(!archive._children);
-  });
-
-  it('should be able to use db to insert documents', async function() {
     const testItems = [
       {
         _id: 'parent:en:published',
@@ -172,9 +121,11 @@ describe('Pages', function() {
       }
     ];
     // Insert draft versions too to match the A3 data model
+    const lastPublishedAt = new Date();
     const draftItems = await apos.doc.db.insertMany(testItems.map(item => ({
       ...item,
       aposLocale: item.aposLocale.replace(':published', ':draft'),
+      lastPublishedAt,
       _id: item._id.replace(':published', ':draft')
     })));
     assert(draftItems.result.ok === 1);
@@ -186,6 +137,57 @@ describe('Pages', function() {
     assert(items.insertedCount === 6);
   });
 
+  after(function() {
+    return t.destroy(apos);
+  });
+
+  // EXISTENCE
+
+  it('should be a property of the apos object', async function() {
+    assert(apos.page.__meta.name === '@apostrophecms/page');
+  });
+
+  // SETUP
+
+  it('should make sure all of the expected indexes are configured', async function() {
+    const expectedIndexes = [ 'path' ];
+    const actualIndexes = [];
+
+    const info = await apos.doc.db.indexInformation();
+
+    // Extract the actual index info we care about
+    _.each(info, function(index) {
+      actualIndexes.push(index[0][0]);
+    });
+
+    // Now make sure everything in expectedIndexes is in actualIndexes
+    _.each(expectedIndexes, function(index) {
+      assert(_.includes(actualIndexes, index));
+    });
+  });
+
+  it('parked homepage exists', async function() {
+    assert(home);
+    assert(home.slug === '/');
+    assert(`${home.path}:en:published` === home._id);
+    assert(home.type === '@apostrophecms/home-page');
+    assert(home.parked);
+    assert(home.visibility === 'public');
+  });
+
+  it('parked archive page exists', async function() {
+    const archive = await apos.page.find(apos.task.getReq(), { slug: '/archive' }).archived(null).toObject();
+    assert(archive);
+    assert(archive.slug === '/archive');
+    assert(archive.path === `${homeId.replace(':en:published', '')}/${archive._id.replace(':en:published', '')}`);
+    assert(archive.type === '@apostrophecms/archive-page');
+    assert(archive.parked);
+    // Verify that clonePermanent did its
+    // job and removed properties not meant
+    // to be stored in mongodb
+    assert(!archive._children);
+  });
+
   // FINDING
 
   it('should have a find method on pages that returns a cursor', async function() {
@@ -278,6 +280,55 @@ describe('Pages', function() {
     assert.strictEqual(page._ancestors[1]._children[1].path, `${homeId.replace(':en:published', '')}/parent/sibling`);
   });
 
+  it('should return pages from a specific type when type is provided', async function () {
+    const result = await apos.http.get('/api/v1/@apostrophecms/page', {
+      qs: {
+        type: 'test-page'
+      }
+    });
+
+    const expected = {
+      results: [
+        {
+          type: 'test-page',
+          slug: '/parent'
+        },
+        {
+          type: 'test-page',
+          slug: '/parent/child'
+        },
+        {
+          type: 'test-page',
+          slug: '/parent/child/grandchild'
+        },
+        {
+          type: 'test-page',
+          slug: '/parent/sibling'
+        },
+        {
+          type: 'test-page',
+          slug: '/parent/sibling/cousin'
+        },
+        {
+          type: 'test-page',
+          slug: '/another-parent'
+        }
+      ],
+      pages: 1,
+      currentPage: 1
+    };
+
+    const mappedResult = result.results.map(({ type, slug }) => ({
+      type,
+      slug
+    }));
+
+    assert.deepEqual({
+      ...result,
+      results: mappedResult
+    }, expected);
+  });
+
   // INSERTING
 
   it('is able to insert a new page', async function() {
@@ -1309,4 +1360,285 @@ describe('Pages', function() {
       });
     });
   });
+
+  describe('publish, move and draft', function () {
+    beforeEach(async function() {
+      await t.destroy(apos);
+      apos = await t.create({
+        root: module,
+        modules: {
+          '@apostrophecms/page': {
+            options: {
+              park: [],
+              types: [
+                {
+                  name: '@apostrophecms/home-page',
+                  label: 'Home'
+                },
+                {
+                  name: 'test-page',
+                  label: 'Test Page'
+                }
+              ]
+            }
+          },
+          'test-page': {
+            extend: '@apostrophecms/page-type'
+          }
+        }
+      });
+    });
+
+    it('should publish and move published after draft doc', async function () {
+      const req = apos.task.getReq({ mode: 'draft' });
+
+      const page1 = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'Root First Page',
+        type: 'test-page',
+        slug: 'root-first-page'
+      });
+      const page2 = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'Root Second Page',
+        type: 'test-page',
+        slug: 'root-second-page'
+      });
+      const page3 = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'Root Third Page',
+        type: 'test-page',
+        slug: 'root-third-page'
+      });
+
+      // Publish and assert.
+      // Obviously, should not throw an error.
+      await apos.page.publish(req, page3);
+      {
+        const pages = await apos.doc.db.find({
+          type: 'test-page'
+        }).sort({ rank: 1 }).toArray();
+
+        const p1Idx = pages.findIndex(p => p._id === page1._id);
+        assert(p1Idx !== -1);
+        const p2Idx = pages.findIndex(p => p._id === page2._id);
+        assert(p2Idx !== -1);
+        const p3Idx = pages.findIndex(p => p._id === page3._id);
+        assert(p3Idx !== -1);
+        const p3IdxPublished = pages.findIndex(p => p._id === page3._id.replace(':draft', ':published'));
+        assert(p3IdxPublished !== -1);
+
+        // first, second, third/third-published
+        assert(p1Idx < p2Idx);
+        assert(p2Idx < p3Idx);
+        assert(p2Idx < p3IdxPublished);
+      }
+
+      // Move and assert.
+      await apos.page.move(req, page3._id, page1._id, 'after');
+      {
+        const pages = await apos.doc.db.find({
+          type: 'test-page'
+        }).sort({ rank: 1 }).toArray();
+
+        const p1Idx = pages.findIndex(p => p._id === page1._id);
+        assert(p1Idx !== -1);
+        const p2Idx = pages.findIndex(p => p._id === page2._id);
+        assert(p2Idx !== -1);
+        const p3Idx = pages.findIndex(p => p._id === page3._id);
+        assert(p3Idx !== -1);
+        const p3IdxPublished = pages.findIndex(p => p._id === page3._id.replace(':draft', ':published'));
+        assert(p3IdxPublished !== -1);
+
+        // first, third/third-published, second
+        assert(p1Idx < p3Idx);
+        assert(p1Idx < p3IdxPublished);
+        assert(p3Idx < p2Idx);
+        assert(p3IdxPublished < p2Idx);
+      }
+    });
+
+    it('should publish and move published after draft doc (nested)', async function () {
+      const req = apos.task.getReq({ mode: 'draft' });
+
+      const root = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'Root Page',
+        type: 'test-page'
+      });
+      await apos.page.publish(req, root);
+
+      const page1 = await apos.page.insert(req, root._id, 'lastChild', {
+        title: 'First Page',
+        type: 'test-page'
+      });
+      const page2 = await apos.page.insert(req, root._id, 'lastChild', {
+        title: 'Second Page',
+        type: 'test-page'
+      });
+      const page3 = await apos.page.insert(req, root._id, 'lastChild', {
+        title: 'Third Page',
+        type: 'test-page'
+      });
+
+      // Publish and assert.
+      // Obviously, should not throw an error.
+      await apos.page.publish(req, page3);
+      {
+        const pages = await apos.doc.db.find({
+          type: 'test-page',
+          level: 2
+        }).sort({
+          level: 1,
+          rank: 1
+        }).toArray();
+
+        const p1Idx = pages.findIndex(p => p._id === page1._id);
+        assert(p1Idx !== -1);
+        assert.equal(pages[p1Idx].path, `${root.path}/${page1.aposDocId}`);
+        const p2Idx = pages.findIndex(p => p._id === page2._id);
+        assert(p2Idx !== -1);
+        assert.equal(pages[p2Idx].path, `${root.path}/${page2.aposDocId}`);
+        const p3Idx = pages.findIndex(p => p._id === page3._id);
+        assert(p3Idx !== -1);
+        assert.equal(pages[p3Idx].path, `${root.path}/${page3.aposDocId}`);
+        const p3IdxPublished = pages.findIndex(p => p._id === page3._id.replace(':draft', ':published'));
+        assert(p3IdxPublished !== -1);
+        assert.equal(pages[p3IdxPublished].path, `${root.path}/${page3.aposDocId}`);
+
+        // first, second, third/third-published
+        assert(p1Idx < p2Idx);
+        assert(p2Idx < p3Idx);
+        assert(p2Idx < p3IdxPublished);
+      }
+
+      // Move and assert.
+      await apos.page.move(req, page3._id, page1._id, 'after');
+      {
+        const pages = await apos.doc.db.find({
+          type: 'test-page',
+          level: 2
+        }).sort({
+          level: 1,
+          rank: 1
+        }).toArray();
+
+        const p1Idx = pages.findIndex(p => p._id === page1._id);
+        assert(p1Idx !== -1);
+        const p2Idx = pages.findIndex(p => p._id === page2._id);
+        assert(p2Idx !== -1);
+        const p3Idx = pages.findIndex(p => p._id === page3._id);
+        assert(p3Idx !== -1);
+        const p3IdxPublished = pages.findIndex(p => p._id === page3._id.replace(':draft', ':published'));
+        assert(p3IdxPublished !== -1);
+
+        // first, third/third-published, second
+        assert(p1Idx < p3Idx);
+        assert(p1Idx < p3IdxPublished);
+        assert(p3Idx < p2Idx);
+        assert(p3IdxPublished < p2Idx);
+      }
+
+      // Publish the last draft and assert it's sorted right.
+      await apos.page.publish(req, page2);
+      {
+        const pages = await apos.doc.db.find({
+          type: 'test-page',
+          level: 2
+        }).sort({
+          level: 1,
+          rank: 1
+        }).toArray();
+
+        const p1Idx = pages.findIndex(p => p._id === page1._id);
+        assert(p1Idx !== -1);
+        const p2Idx = pages.findIndex(p => p._id === page2._id);
+        assert(p2Idx !== -1);
+        const p2IdxPublished = pages.findIndex(p => p._id === page2._id.replace(':draft', ':published'));
+        assert(p2IdxPublished !== -1);
+        const p3Idx = pages.findIndex(p => p._id === page3._id);
+        assert(p3Idx !== -1);
+        const p3IdxPublished = pages.findIndex(p => p._id === page3._id.replace(':draft', ':published'));
+        assert(p3IdxPublished !== -1);
+
+        // first, third/third-published, second
+        assert(p1Idx < p3Idx);
+        assert(p1Idx < p3IdxPublished);
+        assert(p3Idx < p2Idx);
+        assert(p3IdxPublished < p2IdxPublished);
+      }
+    });
+
+    it('should not be able to move published inside draft doc', async function () {
+      const req = apos.task.getReq({ mode: 'draft' });
+
+      const root = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'Root Page',
+        type: 'test-page'
+      });
+
+      const page1 = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'First Page',
+        type: 'test-page'
+      });
+      await apos.page.publish(req, page1);
+
+      await assert.rejects(apos.page.move(req, page1._id, root._id, 'firstChild'), {
+        name: 'forbidden',
+        message: 'Publish the parent page first.'
+      });
+    });
+
+    it('should not be able to publish inside draft doc', async function () {
+      const req = apos.task.getReq({ mode: 'draft' });
+
+      const root = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'Root Page',
+        type: 'test-page'
+      });
+
+      const page1 = await apos.page.insert(req, root._id, 'lastChild', {
+        title: 'First Page',
+        type: 'test-page'
+      });
+
+      await assert.rejects(
+        apos.page.publish(req, page1),
+        (error) => {
+          assert.equal(error.name, 'invalid');
+          assert.equal(error.data?.unpublishedAncestors?.length, 1);
+          assert.equal(error.data.unpublishedAncestors[0].title, 'Root Page');
+          return true;
+        }
+      );
+    });
+
+    it('should not be able to insert publish inside draft doc', async function () {
+      const req = apos.task.getReq({ mode: 'draft' });
+
+      const root = await apos.page.insert(req, '_home', 'lastChild', {
+        title: 'Root Page',
+        type: 'test-page'
+      });
+
+      // Publish directly via insert and req.mode = 'published'.
+      // This can really be done only programmatically, but it's a valid use case.
+      await assert.rejects(
+        apos.page.insert(req.clone({ mode: 'published' }), root._id, 'lastChild', {
+          title: 'First Page',
+          type: 'test-page'
+        }),
+        {
+          name: 'forbidden',
+          message: 'Publish the parent page first.'
+        }
+      );
+
+      // IMPORTANT - assert the published page is gone, the draft is still there.
+      const pages = await apos.doc.db.find({
+        type: 'test-page'
+      }).sort({ rank: 1 }).toArray();
+      const draftPage = pages.find(p => p.title === 'First Page' && p.aposMode === 'draft');
+      const publishedPage = pages.find(p => p.title === 'First Page' && p.aposMode === 'published');
+      assert(draftPage);
+      assert(draftPage.level === 2);
+      assert.equal(typeof publishedPage, 'undefined');
+    });
+  });
 });