apostrophe 3.59.0 → 3.60.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 3.60.0 (2023-11-29)
+
+### Adds
+
+* Add the possibility to add custom classes to notifications.
+Setting the `apos-notification--hidden` class will hide the notification, which can be useful when we only care about the event carried by it.
+* Give the possibility to add horizontal rules from the insert menu of the rich text editor with the following widget option: `insert: [ 'horizontalRule' ]`.
+Improve also the UX to focus back the editor after inserting a horizontal rule or a table.
+
+### Fixes
+
+* The `render-widget` route now provides an `options` property on the widget, so that
+schema-level options of the widget are available to the external front end when
+rendering a newly added or edited widget in the editor. Note that when rendering a full page,
+this information is already available on the parent area: `area.options.widgets[widget.type]`
+* Pages inserted directly in the published mode are now given a
+correct `lastPublishedAt` property, correcting several bugs relating
+to the page tree.
+* A migration has been added to introduce `lastPublishedAt` wherever
+it is missing for existing pages.
+* Fixed a bug that prevented page ranks from renumbering properly during "insert after" operations.
+* Added a one-time migration to make existing page ranks unique among peers.
+* Fixes conditional fields not being properly updated when switching items in array editor.
+* The `beforeSend` event for pages and the loading of deferred widgets are now
+handled in `renderPage` with the proper timing so that areas can be annotated
+successfully for "external front" use.
+* The external front now receives 100% of the serialization-friendly data that Nunjucks receives,
+including the `home` property etc. Note that the responsibility to avoid passing any nonserializable
+or excessively large data in `req.data` falls on the developer when choosing to use the
+`apos-external-front` feature.
+* Wraps the group label in the expanded preview menu component in `$t()` to allow translation
+
+## 3.59.1 (2023-11-14)
+
+### Fixes
+
+* Fix `if` and `requiredIf` fields inside arrays. With regard to `if`, this is a hotfix for a regression introduced in 3.59.0.
+
 ## 3.59.0 (2023-11-03)
 
 ### Changes

package/modules/@apostrophecms/area/index.js

@@ -71,6 +71,7 @@ module.exports = {
             if (req.aposExternalFront) {
               const result = {
                 ...req.data,
+                options,
                 widget
               };
               return result;

package/modules/@apostrophecms/area/ui/apos/components/AposAreaExpandedMenu.vue

@@ -16,7 +16,7 @@
             :key="groupIndex"
             class="apos-widget-group"
           >
-            <h2 class="apos-widget-group__label" v-if="group.label">{{ group.label }}</h2>
+            <h2 class="apos-widget-group__label" v-if="group.label">{{ $t(group.label) }}</h2>
             <div
               :class="[
                 `apos-widget-group--${group.columns}-column${

package/modules/@apostrophecms/doc/index.js

@@ -239,13 +239,22 @@ module.exports = {
           })) {
             return;
           }
+          const lastPublishedAt = doc.createdAt || new Date();
           const draft = {
             ...doc,
             _id: draftId,
             aposLocale: draftLocale,
-            lastPublishedAt: doc.createdAt || new Date()
+            lastPublishedAt
           };
-          return manager.insertDraftOf(req, doc, draft, options);
+          await manager.insertDraftOf(req, doc, draft, options);
+          // Published doc must know it is published, otherwise various bugs ensue
+          return self.apos.doc.db.updateOne({
+            _id: doc._id
+          }, {
+            $set: {
+              lastPublishedAt
+            }
+          });
         }
       },
       fixUniqueError: {

package/modules/@apostrophecms/job/index.js

@@ -285,6 +285,7 @@ module.exports = {
             ids: options.ids
           },
           event,
+          classes: options.classes,
           icon: req.body.messages.icon || 'database-export-icon',
           type: options.type || 'success',
           return: true

package/modules/@apostrophecms/module/index.js

@@ -379,8 +379,8 @@ module.exports = {
         return self.apos.template.renderStringForModule(req, s, data, self);
       },
 
-      // TIP: you probably want `self.sendPage`, which loads
-      // `data.home` for you and also sends the response to the browser.
+      // TIP: more often you will want `self.sendPage`, which also sends the response
+      // to the browser.
       //
       // This method generates a complete HTML page for transmission to the
       // browser. Returns HTML markup ready to send (but `self.sendPage` is
@@ -419,11 +419,19 @@ module.exports = {
       //
       // This method is async in 3.x and must be awaited.
       //
+      // If the external front feature is in use for the request, then
+      // self.apos.template.annotateDataForExternalFront and
+      // self.apos.template.pruneDataForExternalFront are called
+      // and the data is returned, in place of normal Nunjucks rendering.
+      //
       // No longer deprecated because it is a useful override point
       // for this part of the behavior of sendPage.
 
       async renderPage(req, template, data) {
+        await self.apos.page.emit('beforeSend', req);
+        await self.apos.area.loadDeferredWidgets(req);
         if (req.aposExternalFront) {
+          data = self.apos.template.getRenderDataArgs(req, data, self);
           await self.apos.template.annotateDataForExternalFront(req, template, data);
           self.apos.template.pruneDataForExternalFront(req, template, data);
           // Reply with JSON
@@ -484,8 +492,6 @@ module.exports = {
           span.setAttribute(telemetry.Attributes.TEMPLATE, template);
 
           try {
-            await self.apos.page.emit('beforeSend', req);
-            await self.apos.area.loadDeferredWidgets(req);
             const result = await self.renderPage(req, template, data);
             req.res.send(result);
             span.setStatus({ code: telemetry.api.SpanStatusCode.OK });

package/modules/@apostrophecms/notification/index.js

@@ -99,6 +99,7 @@ module.exports = {
       ], 'info');
       const icon = self.apos.launder.string(req.body.icon);
       const message = self.apos.launder.string(req.body.message);
+      const classes = self.apos.launder.strings(req.body.classes);
       const interpolate = launderInterpolate(req.body.interpolate);
       const dismiss = self.apos.launder.integer(req.body.dismiss);
       let buttons = req.body.buttons;
@@ -118,6 +119,7 @@ module.exports = {
         }));
       }
       return self.trigger(req, message, {
+        classes,
         interpolate,
         dismiss,
         icon,
@@ -280,7 +282,8 @@ module.exports = {
           localize: has(req.body, 'localize')
             ? self.apos.launder.boolean(req.body.localize) : true,
           job: options.job || null,
-          event: options.event
+          event: options.event,
+          classes: options.classes || null
         };
 
         if (copiedOptions.dismiss === true) {

package/modules/@apostrophecms/notification/ui/apos/components/AposNotification.vue

@@ -79,6 +79,11 @@ export default {
   computed: {
     classList() {
       const classes = [ 'apos-notification' ];
+
+      if (Array.isArray(this.notification.classes) && this.notification.classes.length) {
+        classes.push(...this.notification.classes);
+      }
+
       if (this.notification.type && this.notification.type !== 'none') {
         classes.push(`apos-notification--${this.notification.type}`);
       }
@@ -223,6 +228,10 @@ export default {
     }
   }
 
+  .apos-notification--hidden {
+    display: none;
+  }
+
   .apos-notification--long {
     border-radius: 10px;
   }

package/modules/@apostrophecms/page/index.js

@@ -101,6 +101,8 @@ module.exports = {
     self.addLegacyMigrations();
     self.addMisreplicatedParkedPagesMigration();
     self.addDuplicateParkedPagesMigration();
+    self.apos.migration.add('deduplicateRanks2', self.deduplicateRanks2Migration);
+    self.apos.migration.add('missingLastPublishedAt', self.missingLastPublishedAtMigration);
     await self.createIndexes();
   },
   restApiRoutes(self) {
@@ -850,8 +852,8 @@ database.`);
         const query = self.find(req, criteria, options).permission('edit').archived(null);
         return query;
       },
-      // Insert a page. `targetId` must be an existing page id, and
-      // `position` may be `before`, `inside` or `after`. Alternatively
+      // Insert a page. `targetId` must be an existing page id, `_archive` or
+      // `_home`, and `position` may be `before`, `inside` or `after`. Alternatively
       // `position` may be a zero-based offset for the new child
       // of `targetId` (note that the `rank` property of sibling pages
       // is not strictly ascending, so use an array index into `_children` to
@@ -930,7 +932,7 @@ database.`);
               return self.insert(req, target._id, 'before', page, options);
             }
             page.rank = target.rank + 1;
-            const index = peers.findIndex(peer => peer.id === target._id);
+            const index = peers.findIndex(peer => peer._id === target._id);
             if (index !== -1) {
               pushed = peers.slice(index + 1).map(peer => peer._id);
             }
@@ -2503,6 +2505,84 @@ database.`);
           }
         });
       },
+      async deduplicateRanks2Migration() {
+        for (const locale of Object.keys(self.apos.i18n.locales)) {
+          for (const mode of [ 'previous', 'draft', 'published' ]) {
+            const pages = await self.apos.doc.db.find({
+              slug: /^\//,
+              aposLocale: `${locale}:${mode}`
+            }, {
+              path: 1,
+              rank: 1,
+              slug: 1
+            }).toArray();
+            const pagesByPath = new Map();
+            for (const page of pages) {
+              page._children = [];
+              pagesByPath.set(page.path, page);
+            }
+            for (const page of pages) {
+              if (page.level === 0) {
+                // Home page has no parent
+                continue;
+              }
+              const parentPath = self.getParentPath(page);
+              const parent = pagesByPath.get(parentPath);
+              if (!parent) {
+                self.apos.util.error(`Warning: page ${page._id} has no parent in the tree`);
+                continue;
+              }
+              parent._children.push(page);
+            }
+            for (const page of pages) {
+              const children = page._children;
+              children.sort((a, b) => a.rank - b.rank);
+              let lastRank = null;
+              let bad = false;
+              for (const child of children) {
+                if (child.rank === lastRank) {
+                  bad = true;
+                  break;
+                }
+                lastRank = child.rank;
+              }
+              if (bad) {
+                self.apos.util.warn(`Fixing ranks for children of ${page.slug} in ${page.aposLocale}`);
+                for (let i = 0; (i < children.length); i++) {
+                  await self.apos.doc.db.updateOne({
+                    _id: children[i]._id
+                  }, {
+                    $set: {
+                      rank: i
+                    }
+                  });
+                }
+              }
+            }
+          }
+        }
+      },
+      missingLastPublishedAtMigration() {
+        return self.apos.migration.eachDoc({
+          aposMode: 'published',
+          lastPublishedAt: null
+        }, async doc => {
+          const draft = await self.apos.doc.db.findOne({
+            _id: doc._id.replace(':published', ':draft')
+          });
+          if (!draft) {
+            self.apos.util.error(`Warning: published document has no matching draft: ${doc._id}`);
+            return;
+          }
+          await self.apos.doc.db.updateOne({
+            _id: doc._id
+          }, {
+            $set: {
+              lastPublishedAt: draft.lastPublishedAt
+            }
+          });
+        });
+      },
       async inferLastTargetIdAndPosition(doc) {
         const parentPath = self.getParentPath(doc);
         const parentAposDocId = parentPath.split('/').pop();

package/modules/@apostrophecms/rich-text-widget/index.js

@@ -220,6 +220,11 @@ module.exports = {
         label: 'apostrophe:image',
         description: 'apostrophe:imageDescription',
         component: 'AposImageControlDialog'
+      },
+      horizontalRule: {
+        icon: 'minus-icon',
+        label: 'apostrophe:richTextHorizontalRule',
+        action: 'setHorizontalRule'
       }
     },
     // Additional properties used in executing tiptap commands

package/modules/@apostrophecms/rich-text-widget/ui/apos/components/AposRichTextWidgetEditor.vue

@@ -590,6 +590,7 @@ export default {
       } else {
         this.removeSlash();
         this.editor.commands[info.action || name]();
+        this.editor.commands.focus();
       }
     },
     removeSlash() {

package/modules/@apostrophecms/schema/index.js

@@ -498,10 +498,10 @@ module.exports = {
             }
             continue;
           } else if (val.$ne) {
-            // eslint-disable-next-line eqeqeq
-            if (val.$ne == destinationKey) {
+            if (val.$ne === destinationKey) {
               return false;
             }
+            continue;
           }
 
           // Handle external conditions:
@@ -526,23 +526,22 @@ module.exports = {
             continue;
           }
 
-          if (val.min && destinationKey < val.min) {
-            return false;
-          }
-          if (val.max && destinationKey > val.max) {
-            return false;
+          // test with Object.prototype for the case val.min === 0
+          if (Object.hasOwn(val, 'min') || Object.hasOwn(val, 'max')) {
+            if (destinationKey < val.min) {
+              return false;
+            }
+            if (destinationKey > val.max) {
+              return false;
+            }
+            continue;
           }
 
           if (conditionalFields?.[key] === false) {
             return false;
           }
 
-          if (typeof val === 'boolean' && !destinationKey) {
-            return false;
-          }
-
-          // eslint-disable-next-line eqeqeq
-          if ((typeof val === 'string' || typeof val === 'number') && destinationKey != val) {
+          if (destinationKey !== val) {
             return false;
           }
         }

package/modules/@apostrophecms/schema/ui/apos/logic/AposArrayEditor.js

@@ -138,9 +138,8 @@ export default {
   async mounted() {
     this.modal.active = true;
     await this.evaluateExternalConditions();
-    this.evaluateConditions();
     if (this.next.length) {
-      this.select(this.next[0]._id);
+      await this.select(this.next[0]._id);
     }
     if (this.serverError && this.serverError.data && this.serverError.data.errors) {
       const first = this.serverError.data.errors[0];
@@ -168,6 +167,7 @@ export default {
           hasErrors: false,
           data: this.next.find(item => item._id === _id)
         };
+        this.evaluateConditions();
         this.triggerValidation = false;
       }
     },
@@ -193,7 +193,7 @@ export default {
         const item = this.newInstance();
         item._id = cuid();
         this.next.push(item);
-        this.select(item._id);
+        await this.select(item._id);
         this.updateMinMax();
       }
     },

package/modules/@apostrophecms/template/index.js

@@ -276,35 +276,15 @@ module.exports = {
       },
 
       // Implementation detail of `renderBody` responsible for
-      // creating the input object passed to Nunjucks for rendering,
-      // with `data` merged into the `.data` property,
-      // `apos` available separately, `__req` available separately, etc.
+      // creating the input object passed to the template engine e.g. Nunjucks.
+      // Includes both serializable data like `user` and non-JSON-friendly
+      // properties like `apos`, `getOptions()` and `__req`. If you are only
+      // interested in serializable data use `getRenderDataArgs`
 
       getRenderArgs(req, data, module) {
-        const merged = {};
-
-        if (data) {
-          _.defaults(merged, data);
-        }
-
-        const args = {};
-
-        args.data = merged;
-
-        if (req.data) {
-          _.defaults(merged, req.data);
-        }
-        _.defaults(merged, {
-          user: req.user,
-          permissions: (req.user && req.user._permissions) || {}
-        });
-
-        if (module.templateData) {
-          _.defaults(merged, module.templateData);
-        }
-
-        args.data.locale = args.data.locale || req.locale;
-
+        const args = {
+          data: self.getRenderDataArgs(req, data, module)
+        };
         args.apos = self.templateApos;
         args.__t = req.t;
         args.__ = key => {
@@ -328,6 +308,33 @@ module.exports = {
         return args;
       },
 
+      // Just the external front-compatible parts of `getRenderArgs` that
+      // go into `args.data` for Nunjucks, e.g. merging `req.data` and `data`, adding
+      // `req.user` as `user`, etc.
+
+      getRenderDataArgs(req, data, module) {
+        const merged = {};
+
+        if (data) {
+          _.defaults(merged, data);
+        }
+
+        if (req.data) {
+          _.defaults(merged, req.data);
+        }
+        _.defaults(merged, {
+          user: req.user,
+          permissions: (req.user && req.user._permissions) || {}
+        });
+
+        if (module.templateData) {
+          _.defaults(merged, module.templateData);
+        }
+
+        merged.locale = merged.locale || req.locale;
+        return merged;
+      },
+
       // Fetch a nunjucks environment in which `include`, `extends`, etc. search
       // the views directories of the specified module and its ancestors.
       // Typically you will call `self.render` on your module
@@ -897,7 +904,7 @@ module.exports = {
       },
 
       getDocsForExternalFront(req, template, data) {
-        return [ data.page, data.piece, ...(data.pieces || []) ].filter(doc => !!doc);
+        return [ data.home, ...(data.page?._ancestors || []), ...(data.page?._children || []), data.page, data.piece, ...(data.pieces || []) ].filter(doc => !!doc);
       },
 
       annotateDocForExternalFront(doc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apostrophe",
-  "version": "3.59.0",
+  "version": "3.60.0",
   "description": "The Apostrophe Content Management System.",
   "main": "index.js",
   "scripts": {

package/test/external-front.js

@@ -0,0 +1,43 @@
+const t = require('../test-lib/test.js');
+const assert = require('assert');
+
+let apos;
+// Set env var so these tests work even if you have a dev key in your bashrc etc.
+process.env.APOS_EXTERNAL_FRONT_KEY = 'this is a test external front key';
+
+describe('External Front', function() {
+
+  this.timeout(t.timeout);
+
+  after(function() {
+    return t.destroy(apos);
+  });
+
+  it('apostrophe should initialize normally', async function() {
+    apos = await t.create({
+      root: module
+    });
+
+    assert(apos.page.__meta.name === '@apostrophecms/page');
+  });
+
+  it('fetch home with external front', async function() {
+    const data = await await apos.http.get('/', {
+      headers: {
+        'x-requested-with': 'AposExternalFront',
+        'apos-external-front-key': process.env.APOS_EXTERNAL_FRONT_KEY
+      }
+    });
+    assert.strictEqual(typeof data, 'object');
+    assert(data.page);
+    assert(data.home);
+    assert(data.page.slug === data.home.slug);
+    assert(data.page.slug === '/');
+  });
+
+  it('fetch home normally', async function() {
+    const data = await await apos.http.get('/', {});
+    assert.strictEqual(typeof data, 'string');
+    assert(data.includes('Home Page Template'));
+  });
+});

package/test/pages-rest.js

@@ -192,6 +192,7 @@ describe('Pages REST', function() {
   });
 
   it('should be able to use db to insert documents', async function() {
+    const lastPublishedAt = new Date();
     const testItems = [
       {
         _id: 'parent:en:published',
@@ -202,7 +203,8 @@ describe('Pages REST', function() {
         visibility: 'public',
         path: `${homeId.replace(':en:published', '')}/parent`,
         level: 1,
-        rank: 0
+        rank: 0,
+        lastPublishedAt
       },
       {
         _id: 'child:en:published',
@@ -213,7 +215,8 @@ describe('Pages REST', function() {
         visibility: 'public',
         path: `${homeId.replace(':en:published', '')}/parent/child`,
         level: 2,
-        rank: 0
+        rank: 0,
+        lastPublishedAt
       },
       {
         _id: 'grandchild:en:published',
@@ -224,7 +227,8 @@ describe('Pages REST', function() {
         visibility: 'public',
         path: `${homeId.replace(':en:published', '')}/parent/child/grandchild`,
         level: 3,
-        rank: 0
+        rank: 0,
+        lastPublishedAt
       },
       {
         _id: 'sibling:en:published',
@@ -235,8 +239,8 @@ describe('Pages REST', function() {
         visibility: 'public',
         path: `${homeId.replace(':en:published', '')}/parent/sibling`,
         level: 2,
-        rank: 1
-
+        rank: 1,
+        lastPublishedAt
       },
       {
         _id: 'cousin:en:published',
@@ -247,7 +251,8 @@ describe('Pages REST', function() {
         visibility: 'public',
         path: `${homeId.replace(':en:published', '')}/parent/sibling/cousin`,
         level: 3,
-        rank: 0
+        rank: 0,
+        lastPublishedAt
       },
       {
         _id: 'another-parent:en:published',
@@ -258,7 +263,8 @@ describe('Pages REST', function() {
         visibility: 'public',
         path: `${homeId.replace(':en:published', '')}/another-parent`,
         level: 1,
-        rank: 1
+        rank: 1,
+        lastPublishedAt
       },
       {
         _id: 'neighbor:en:published',
@@ -269,7 +275,8 @@ describe('Pages REST', function() {
         visibility: 'public',
         path: `${homeId.replace(':en:published', '')}/neighbor`,
         level: 1,
-        rank: 2
+        rank: 2,
+        lastPublishedAt
       }
     ];
 
@@ -482,7 +489,6 @@ describe('Pages REST', function() {
       },
       jar
     });
-
     const cousin = await apos.http.get('/api/v1/@apostrophecms/page/cousin:en:published', { jar });
     const sibling = await apos.http.get('/api/v1/@apostrophecms/page/sibling:en:published', { jar });
 

package/test/published-pages.js

@@ -0,0 +1,144 @@
+const t = require('../test-lib/test.js');
+const assert = require('assert');
+
+let apos;
+
+describe('Pages', function() {
+
+  this.timeout(t.timeout);
+
+  after(function() {
+    return t.destroy(apos);
+  });
+
+  // EXISTENCE
+
+  it('should be a property of the apos object', async function() {
+    apos = await t.create({
+      root: module,
+      modules: {
+        '@apostrophecms/page': {
+          options: {
+            park: [],
+            types: [
+              {
+                name: '@apostrophecms/home-page',
+                label: 'Home'
+              },
+              {
+                name: 'test-page',
+                label: 'Test Page'
+              }
+            ],
+            publicApiProjection: {
+              title: 1,
+              _url: 1
+            }
+          }
+        },
+        'test-page': {
+          extend: '@apostrophecms/page-type'
+        }
+      }
+    });
+
+    assert(apos.page.__meta.name === '@apostrophecms/page');
+  });
+
+  it('inserting child pages with a published req should produce the correct draft/published pairs', async function() {
+    const req = apos.task.getAdminReq();
+    const manager = apos.doc.getManager('test-page');
+
+    for (let i = 1; (i <= 10); i++) {
+      const page = manager.newInstance();
+      page.title = `test-child-${i}`;
+      page.type = 'test-page';
+      const { _id } = await apos.page.insert(req, '_home', 'lastChild', page, {});
+      const fetchedPage = await apos.page.find(req, { _id }).toObject();
+      assert.strictEqual(fetchedPage.aposMode, 'published');
+      assert(fetchedPage);
+      const draftReq = req.clone({
+        mode: 'draft'
+      });
+      const draft = await apos.page.find(draftReq, {
+        aposDocId: fetchedPage.aposDocId
+      }).toObject();
+      assert(draft);
+      assert.strictEqual(draft.aposMode, 'draft');
+      assert(draft.level === fetchedPage.level);
+      assert(draft.lastPublishedAt);
+      assert(fetchedPage.lastPublishedAt);
+      assert(draft.lastPublishedAt.getTime() === fetchedPage.lastPublishedAt.getTime());
+    }
+    assert(checkRanks('en:published'));
+    assert(checkRanks('en:draft'));
+  });
+
+  it('Can fix the ranks after intentionally messing them up', async function() {
+    for (let i = 5; (i <= 10); i++) {
+      await apos.doc.db.updateMany({
+        title: `test-child-${i}`
+      }, {
+        $set: {
+          rank: i - 2
+        }
+      });
+    }
+    try {
+      await checkRanks('en:published');
+      assert(false);
+    } catch (e) {
+      // Good, supposed to fail
+    }
+    try {
+      await checkRanks('en:draft');
+      assert(false);
+    } catch (e) {
+      // Good, supposed to fail
+    }
+    await apos.page.deduplicateRanks2Migration();
+    await checkRanks('en:published');
+    await checkRanks('en:draft');
+  });
+
+  it('Can fix lastPublishedAt after intentionally messing it up', async function() {
+    let published = await apos.doc.db.findOne({
+      aposLocale: 'en:published',
+      slug: '/test-child-1'
+    });
+    assert(published.lastPublishedAt);
+    await apos.doc.db.updateOne({
+      _id: published._id
+    }, {
+      $unset: {
+        lastPublishedAt: 1
+      }
+    });
+    published = await apos.doc.db.findOne({
+      aposLocale: 'en:published',
+      slug: '/test-child-1'
+    });
+    assert(!published.lastPublishedAt);
+    await apos.page.missingLastPublishedAtMigration();
+    published = await apos.doc.db.findOne({
+      aposLocale: 'en:published',
+      slug: '/test-child-1'
+    });
+    assert(published.lastPublishedAt);
+  });
+});
+
+async function checkRanks(aposLocale) {
+  const pages = await apos.doc.db.find({
+    level: 1,
+    aposLocale
+  }).project({
+    slug: 1,
+    rank: 1,
+    title: 1
+  }).toArray();
+  for (let i = 1; (i <= 10); i++) {
+    assert(pages.find(page => (page.rank === i - 1) && page.title === `test-child-${i}`));
+  }
+  assert(pages.find(page => (page.slug === '/archive') && (page.rank === 10)));
+}

package/test/schemas.js

@@ -2381,7 +2381,9 @@ describe('Schemas', function() {
 
       assert.deepEqual(actual, expected);
     });
+  });
 
+  describe('field if|ifRequired', function () {
     it('should enforce required property not equal match', async function() {
       const req = apos.task.getReq();
       const schema = apos.schema.compose({
@@ -2468,10 +2470,7 @@ describe('Schemas', function() {
           subfield: false
         }
       }, output);
-      console.log('output', require('util').inspect(output, {
-        colors: true,
-        depth: 1
-      }));
+
       assert(!output.requiredProp);
     });
 
@@ -2676,6 +2675,120 @@ describe('Schemas', function() {
       }, 'requiredProp', 'required');
     });
 
+    it('should enforce required property number min', async function() {
+      const req = apos.task.getReq();
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'prop1',
+            type: 'integer',
+            required: false
+          },
+          {
+            name: 'prop2',
+            type: 'string',
+            required: true,
+            if: {
+              prop1: {
+                min: 0,
+                max: 10
+              }
+            }
+          }
+        ]
+      });
+      const output = {};
+      await apos.schema.convert(req, schema, {
+        prop1: -1,
+        prop2: ''
+      }, output);
+      assert(output.prop2 === '');
+    });
+
+    it('should error required property number min', async function() {
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'prop1',
+            type: 'integer',
+            required: false
+          },
+          {
+            name: 'prop2',
+            type: 'string',
+            required: true,
+            if: {
+              prop1: {
+                min: 0,
+                max: 10
+              }
+            }
+          }
+        ]
+      });
+      await testSchemaError(schema, {
+        prop1: 0,
+        prop2: ''
+      }, 'prop2', 'required');
+    });
+
+    it('should enforce required property number max', async function() {
+      const req = apos.task.getReq();
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'prop1',
+            type: 'integer',
+            required: false
+          },
+          {
+            name: 'prop2',
+            type: 'string',
+            required: true,
+            if: {
+              prop1: {
+                min: -10,
+                max: 0
+              }
+            }
+          }
+        ]
+      });
+      const output = {};
+      await apos.schema.convert(req, schema, {
+        prop1: 1,
+        prop2: ''
+      }, output);
+      assert(output.prop2 === '');
+    });
+
+    it('should error required property number max', async function() {
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'prop1',
+            type: 'integer',
+            required: false
+          },
+          {
+            name: 'prop2',
+            type: 'string',
+            required: true,
+            if: {
+              prop1: {
+                min: -10,
+                max: 0
+              }
+            }
+          }
+        ]
+      });
+      await testSchemaError(schema, {
+        prop1: 0,
+        prop2: ''
+      }, 'prop2', 'required');
+    });
+
     it('should enforce required property nested logical AND', async function() {
       const req = apos.task.getReq();
       const schema = apos.schema.compose({
@@ -2956,48 +3069,49 @@ describe('Schemas', function() {
       const schema = apos.schema.compose({
         addFields: [
           {
-            name: 'age',
-            type: 'integer',
+            name: 'prop1',
+            type: 'boolean',
             required: false
           },
           {
-            name: 'shoeSize',
-            type: 'integer',
+            name: 'prop2',
+            type: 'string',
             requiredIf: {
-              age: true
+              prop1: true
             }
           }
         ]
       });
       const output = {};
       await apos.schema.convert(req, schema, {
-        shoeSize: '',
-        age: ''
+        prop1: false,
+        prop2: ''
       }, output);
-      assert(output.shoeSize === null);
+
+      assert(output.prop2 === '');
     });
 
     it('should error required property with ifRequired boolean', async function() {
       const schema = apos.schema.compose({
         addFields: [
           {
-            name: 'age',
-            type: 'integer',
+            name: 'prop1',
+            type: 'boolean',
             required: false
           },
           {
-            name: 'shoeSize',
-            type: 'integer',
+            name: 'prop2',
+            type: 'string',
             requiredIf: {
-              age: true
+              prop1: true
             }
           }
         ]
       });
       await testSchemaError(schema, {
-        shoeSize: '',
-        age: '18'
-      }, 'shoeSize', 'required');
+        prop1: true,
+        prop2: ''
+      }, 'prop2', 'required');
     });
 
     it('should enforce required property with ifRequired string', async function() {
@@ -3006,7 +3120,7 @@ describe('Schemas', function() {
         addFields: [
           {
             name: 'age',
-            type: 'integer',
+            type: 'string',
             required: false
           },
           {
@@ -3031,7 +3145,7 @@ describe('Schemas', function() {
         addFields: [
           {
             name: 'age',
-            type: 'integer',
+            type: 'string',
             required: false
           },
           {
@@ -3135,8 +3249,29 @@ describe('Schemas', function() {
             required: false
           },
           {
-            name: 'prop2',
-            type: 'boolean',
+            name: 'shoeSize',
+            type: 'integer',
+            requiredIf: {
+              age: {
+                min: 18
+              }
+            }
+          }
+        ]
+      });
+      await testSchemaError(schema, {
+        shoeSize: '',
+        age: 19
+      }, 'shoeSize', 'required');
+    });
+
+    it('should enforce required property with ifRequired number min 0', async function() {
+      const req = apos.task.getReq();
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'age',
+            type: 'integer',
             required: false
           },
           {
@@ -3144,7 +3279,34 @@ describe('Schemas', function() {
             type: 'integer',
             requiredIf: {
               age: {
-                min: 18
+                min: 1
+              }
+            }
+          }
+        ]
+      });
+      const output = {};
+      await apos.schema.convert(req, schema, {
+        shoeSize: '',
+        age: 0
+      }, output);
+      assert(output.shoeSize === null);
+    });
+
+    it('should error required property with ifRequired number min 0', async function() {
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'age',
+            type: 'integer',
+            required: false
+          },
+          {
+            name: 'shoeSize',
+            type: 'integer',
+            requiredIf: {
+              age: {
+                min: 0
               }
             }
           }
@@ -3152,8 +3314,7 @@ describe('Schemas', function() {
       });
       await testSchemaError(schema, {
         shoeSize: '',
-        age: 19,
-        prop2: false
+        age: 0
       }, 'shoeSize', 'required');
     });
 
@@ -3194,11 +3355,6 @@ describe('Schemas', function() {
             type: 'integer',
             required: false
           },
-          {
-            name: 'prop2',
-            type: 'boolean',
-            required: false
-          },
           {
             name: 'shoeSize',
             type: 'integer',
@@ -3217,6 +3373,61 @@ describe('Schemas', function() {
       }, 'shoeSize', 'required');
     });
 
+    it('should enforce required property with ifRequired number max 0', async function() {
+      const req = apos.task.getReq();
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'prop1',
+            type: 'integer',
+            required: false
+          },
+          {
+            name: 'prop2',
+            type: 'string',
+            requiredIf: {
+              prop1: {
+                min: -10,
+                max: 0
+              }
+            }
+          }
+        ]
+      });
+      const output = {};
+      await apos.schema.convert(req, schema, {
+        prop1: 1,
+        prop2: ''
+      }, output);
+      assert(output.prop2 === '');
+    });
+
+    it('should error required property with ifRequired number max 0', async function() {
+      const schema = apos.schema.compose({
+        addFields: [
+          {
+            name: 'prop1',
+            type: 'integer',
+            required: false
+          },
+          {
+            name: 'prop2',
+            type: 'string',
+            requiredIf: {
+              prop1: {
+                min: -10,
+                max: 0
+              }
+            }
+          }
+        ]
+      });
+      await testSchemaError(schema, {
+        prop1: 0,
+        prop2: ''
+      }, 'prop2', 'required');
+    });
+
     it('should enforce required property with ifRequired logical AND', async function() {
       const req = apos.task.getReq();
       const schema = apos.schema.compose({
@@ -4080,7 +4291,6 @@ describe('Schemas', function() {
 
       await testSchemaError(schema, {}, 'age', 'required');
     });
-
   });
 });