apostrophe 3.66.0 → 3.67.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 3.67.0 (2024-06-12)
+
+### Changes
+
+* When moving a page, recognize when the slug of a new child
+already contains the new parent's slug and not double it.
+For example, given we have two pages as children of the home page, page A and page B.
+Page A and page B are siblings.
+Page A has the slug `/peer` and page B has the slug `/peer/page`.
+Now we want page B to be the child of page A.
+We will now end up with page B slug as `/peer/page` and not `/peer/peer/page` as before.
+
+### Fixes
+
+* Updating schema fields as read-only no longer reset the value when updating the document.
+
 ## 3.66.0 (2024-05-15)
 
 ### Fixes
@@ -7,8 +23,6 @@
 * Autocrop image attachments for referenced documents when replacing an image in the Media Manager.
 * Backports some internal A4 UI logic for metadata to make the new `document-versions` comparison feature compatible with A3.
 
-# Changelog
-
 ## 3.65.0 (2024-05-06)
 
 * Adds a `publicBundle` option to `@apostrophecms/asset`. When set to `false`, the `ui/src` public asset bundle is not built at all in most cases

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

@@ -1275,11 +1275,14 @@ database.`);
             if (parent._id !== oldParent._id) {
               const matchOldParentSlugPrefix = new RegExp('^' + self.apos.util.regExpQuote(self.apos.util.addSlashIfNeeded(oldParent.slug)));
               if (moved.slug.match(matchOldParentSlugPrefix)) {
-                let slugStem = parent.slug;
-                if (slugStem !== '/') {
-                  slugStem += '/';
-                }
-                moved.slug = moved.slug.replace(matchOldParentSlugPrefix, self.apos.util.addSlashIfNeeded(parent.slug));
+                const movedSlugCandidate = moved.slug
+                  .split('/')
+                  .slice(0, -1)
+                  .join('/');
+
+                moved.slug = parent.slug.endsWith(movedSlugCandidate)
+                  ? parent.slug.replace(movedSlugCandidate, '').concat(moved.slug)
+                  : moved.slug.replace(matchOldParentSlugPrefix, self.apos.util.addSlashIfNeeded(parent.slug));
                 changed.push({
                   _id: moved._id,
                   slug: moved.slug

package/modules/@apostrophecms/schema/lib/addFieldTypes.js

@@ -786,8 +786,12 @@ module.exports = (self) => {
       }
       const errors = [];
       for (const datum of data) {
-        const result = {};
-        result._id = self.apos.launder.id(datum._id) || self.apos.util.generateId();
+        const _id = self.apos.launder.id(datum._id) || self.apos.util.generateId();
+        const [ found ] = destination[field.name]?.filter?.(item => item._id === _id) || [];
+        const result = {
+          ...(found || {}),
+          _id
+        };
         result.metaType = 'arrayItem';
         result.scopedArrayName = field.scopedArrayName;
         try {
@@ -859,7 +863,7 @@ module.exports = (self) => {
       if (one[field.name].length !== two[field.name].length) {
         return false;
       }
-      for (let i = 0; (i < one.length); i++) {
+      for (let i = 0; (i < one[field.name].length); i++) {
         if (!self.isEqual(req, field.schema, one[field.name][i], two[field.name][i])) {
           return false;
         }
@@ -876,6 +880,7 @@ module.exports = (self) => {
       const schema = field.schema;
       const errors = [];
       const result = {
+        ...(destination[field.name] || {}),
         _id: self.apos.launder.id(data && data._id) || self.apos.util.generateId()
       };
       if (data == null || typeof data !== 'object' || Array.isArray(data)) {
@@ -1027,7 +1032,7 @@ module.exports = (self) => {
           const result = results.find(doc => (doc._id === item._id));
           if (result) {
             if (field.schema) {
-              result._fields = {};
+              result._fields = { ...(destination[field.name]?.find?.(doc => doc._id === item._id)?._fields || {}) };
               if (item && ((typeof item._fields === 'object'))) {
                 await self.convert(req, field.schema, item._fields || {}, result._fields);
               }

package/package.json

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

package/test/pages.js

@@ -457,6 +457,233 @@ describe('Pages', function() {
     assert.strictEqual(page.path, `${homeId.replace(':en:published', '')}/another-parent/parent/sibling`);
   });
 
+  describe('move peer pages', function () {
+    this.afterEach(async function() {
+      await apos.doc.db.deleteMany({
+        type: 'test-page'
+      });
+    });
+
+    it('moving /bar under /foo should wind up with /foo/bar', async function() {
+      const fooPage = await apos.page.insert(
+        apos.task.getReq(),
+        '_home',
+        'lastChild',
+        {
+          slug: '/foo',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Foo Page'
+        }
+      );
+      const barPage = await apos.page.insert(
+        apos.task.getReq(),
+        '_home',
+        'lastChild',
+        {
+          slug: '/bar',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Bar Page'
+        }
+      );
+      const childPage = await apos.page.insert(
+        apos.task.getReq(),
+        barPage._id,
+        'lastChild',
+        {
+          slug: '/bar/child',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Child Page'
+        }
+      );
+
+      await apos.page.move(
+        apos.task.getReq(),
+        barPage._id,
+        fooPage._id,
+        'lastChild'
+      );
+
+      const movedPage = await apos.page.find(apos.task.getAnonReq(), { _id: barPage._id }).toObject();
+      const movedChildPage = await apos.page.find(apos.task.getAnonReq(), { _id: childPage._id }).toObject();
+
+      const actual = {
+        bar: {
+          path: movedPage.path,
+          rank: movedPage.rank,
+          slug: movedPage.slug
+        },
+        child: {
+          path: movedChildPage.path,
+          rank: movedChildPage.rank,
+          slug: movedChildPage.slug
+        }
+      };
+      const expected = {
+        bar: {
+          path: fooPage.path.concat('/', barPage.aposDocId),
+          rank: 0,
+          slug: '/foo/bar'
+        },
+        child: {
+          path: movedPage.path.concat('/', childPage.aposDocId),
+          rank: 0,
+          slug: '/foo/bar/child'
+        }
+      };
+
+      assert.deepEqual(actual, expected);
+    });
+
+    it('moving peer /foo/bar under /foo should wind up with /foo/bar', async function() {
+      const fooPage = await apos.page.insert(
+        apos.task.getReq(),
+        '_home',
+        'lastChild',
+        {
+          slug: '/foo',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Foo Page'
+        }
+      );
+      const barPage = await apos.page.insert(
+        apos.task.getReq(),
+        '_home',
+        'lastChild',
+        {
+          slug: '/foo/bar',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Bar Page'
+        }
+      );
+      const childPage = await apos.page.insert(
+        apos.task.getReq(),
+        barPage._id,
+        'lastChild',
+        {
+          slug: '/foo/bar/child',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Child Page'
+        }
+      );
+
+      await apos.page.move(
+        apos.task.getReq(),
+        barPage._id,
+        fooPage._id,
+        'lastChild'
+      );
+
+      const movedPage = await apos.page.find(apos.task.getAnonReq(), { _id: barPage._id }).toObject();
+      const movedChildPage = await apos.page.find(apos.task.getAnonReq(), { _id: childPage._id }).toObject();
+
+      const actual = {
+        bar: {
+          path: movedPage.path,
+          rank: movedPage.rank,
+          slug: movedPage.slug
+        },
+        child: {
+          path: movedChildPage.path,
+          rank: movedChildPage.rank,
+          slug: movedChildPage.slug
+        }
+      };
+      const expected = {
+        bar: {
+          path: fooPage.path.concat('/', barPage.aposDocId),
+          rank: 0,
+          slug: '/foo/bar'
+        },
+        child: {
+          path: movedPage.path.concat('/', childPage.aposDocId),
+          rank: 0,
+          slug: '/foo/bar/child'
+        }
+      };
+
+      assert.deepEqual(actual, expected);
+    });
+
+    it('moving /foobar under /foo should wind up with /foo/foobar', async function() {
+      const fooPage = await apos.page.insert(
+        apos.task.getReq(),
+        '_home',
+        'lastChild',
+        {
+          slug: '/foo',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Foo Page'
+        }
+      );
+      const foobarPage = await apos.page.insert(
+        apos.task.getReq(),
+        '_home',
+        'lastChild',
+        {
+          slug: '/foobar',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Foobar Page'
+        }
+      );
+      const childPage = await apos.page.insert(
+        apos.task.getReq(),
+        foobarPage._id,
+        'lastChild',
+        {
+          slug: '/foobar/child',
+          visibility: 'public',
+          type: 'test-page',
+          title: 'Child Page'
+        }
+      );
+
+      await apos.page.move(
+        apos.task.getReq(),
+        foobarPage._id,
+        fooPage._id,
+        'lastChild'
+      );
+
+      const movedPage = await apos.page.find(apos.task.getAnonReq(), { _id: foobarPage._id }).toObject();
+      const movedChildPage = await apos.page.find(apos.task.getAnonReq(), { _id: childPage._id }).toObject();
+
+      const actual = {
+        foobar: {
+          path: movedPage.path,
+          rank: movedPage.rank,
+          slug: movedPage.slug
+        },
+        child: {
+          path: movedChildPage.path,
+          rank: movedChildPage.rank,
+          slug: movedChildPage.slug
+        }
+      };
+      const expected = {
+        foobar: {
+          path: fooPage.path.concat('/', foobarPage.aposDocId),
+          rank: 0,
+          slug: '/foo/foobar'
+        },
+        child: {
+          path: movedPage.path.concat('/', childPage.aposDocId),
+          rank: 0,
+          slug: '/foo/foobar/child'
+        }
+      };
+
+      assert.deepEqual(actual, expected);
+    });
+  });
+
   it('inferred page relationships are correct', async function() {
     const req = apos.task.getReq();
     const pages = await apos.page.find(req, {}).toArray();

package/test/schemas.js

@@ -288,6 +288,44 @@ describe('Schemas', function() {
               }
             };
           }
+        },
+        article: {
+          extend: '@apostrophecms/piece-type',
+          options: {
+            alias: 'article'
+          },
+          fields(self) {
+            return {
+              add: {
+                title: {
+                  label: '',
+                  type: 'string',
+                  required: true
+                },
+                area: {
+                  label: 'Area',
+                  type: 'area',
+                  options: {
+                    widgets: {
+                      '@apostrophecms/rich-text': {}
+                    }
+                  }
+                },
+                array: {
+                  label: 'Array',
+                  type: 'array',
+                  fields: {
+                    add: {
+                      arrayTitle: {
+                        label: 'Array Title',
+                        type: 'string'
+                      }
+                    }
+                  }
+                }
+              }
+            };
+          }
         }
       }
     });
@@ -2263,6 +2301,290 @@ describe('Schemas', function() {
     assert(output.goodValue === '2022-05-09T22:36:00.000Z');
   });
 
+  it('should compare two document properly with the method getChanges', async function() {
+    const req = apos.task.getReq();
+    const instance = apos.article.newInstance();
+    const article1 = {
+      ...instance,
+      title: 'article 1',
+      area: {
+        _id: 'clrth36680007mnmd3jj7cta0',
+        items: [
+          {
+            _id: 'clt79l48g001h2061j5ihxjkv',
+            metaType: 'widget',
+            type: '@apostrophecms/rich-text',
+            aposPlaceholder: false,
+            content: '<p>Some text here.</p>',
+            permalinkIds: [],
+            imageIds: []
+          }
+        ],
+        metaType: 'area'
+      },
+      array: [
+        {
+          _id: 'clt79llm800242061v4dx9kv5',
+          metaType: 'arrayItem',
+          scopedArrayName: 'doc.article.array',
+          arrayTitle: 'array title 1'
+        },
+        {
+          _id: 'clt79llm800242061v4d47364',
+          metaType: 'arrayItem',
+          scopedArrayName: 'doc.article.array',
+          arrayTitle: 'array title 2'
+        }
+      ]
+    };
+    const article2 = {
+      ...article1,
+      title: 'article 2'
+    };
+    const article3 = {
+      ...instance,
+      title: 'article 3',
+
+      area: {
+        _id: 'clrth36680007mnmd3jj7cta0',
+        items: [
+          {
+            _id: 'clt79l48g001h2061j5ihxjkv',
+            metaType: 'widget',
+            type: '@apostrophecms/rich-text',
+            aposPlaceholder: false,
+            content: '<p>Some text here changed.</p>',
+            permalinkIds: [],
+            imageIds: []
+          }
+        ],
+        metaType: 'area'
+      },
+      array: [
+        {
+          _id: 'clt79llm800242061v4dx9kv5',
+          metaType: 'arrayItem',
+          scopedArrayName: 'doc.article.array',
+          arrayTitle: 'array title 1 changed'
+        },
+        {
+          _id: 'clt79llm800242061v4d47364',
+          metaType: 'arrayItem',
+          scopedArrayName: 'doc.article.array',
+          arrayTitle: 'array title 2'
+        }
+      ]
+    };
+
+    await apos.article.insert(req, article1);
+    await apos.article.insert(req, article2);
+    await apos.article.insert(req, article3);
+
+    const art1 = await apos.doc.db.findOne({ title: 'article 1' });
+    const art2 = await apos.doc.db.findOne({ title: 'article 2' });
+    const art3 = await apos.doc.db.findOne({ title: 'article 3' });
+
+    const changes11 = apos.schema.getChanges(req, apos.article.schema, art1, art1);
+    const changes12 = apos.schema.getChanges(req, apos.article.schema, art1, art2);
+    const changes23 = apos.schema.getChanges(req, apos.article.schema, art2, art3);
+    const actual = {
+      changes11,
+      changes12,
+      changes23
+    };
+    const expected = {
+      changes11: [],
+      changes12: [ 'title', 'slug' ],
+      changes23: [ 'title', 'slug', 'area', 'array' ]
+    };
+
+    assert.deepEqual(actual, expected);
+  });
+
+  describe('field.readOnly with default value', function() {
+    const givenSchema = [
+      {
+        name: 'title',
+        type: 'string'
+      },
+      {
+        name: 'array',
+        type: 'array',
+        schema: [
+          {
+            name: 'planet',
+            type: 'string',
+            def: 'Earth',
+            readOnly: true
+          },
+          {
+            name: 'moon',
+            type: 'string'
+          }
+        ]
+      },
+      {
+        name: 'object',
+        type: 'object',
+        schema: [
+          {
+            name: 'planet',
+            type: 'string',
+            def: 'Earth',
+            readOnly: true
+          },
+          {
+            name: 'moon',
+            type: 'string'
+          }
+        ]
+      },
+      {
+        name: '_relationship',
+        type: 'relationship',
+        limit: 1,
+        withType: '@apostrophecms/any-page-type',
+        label: 'Page Title',
+        idsStorage: 'pageId',
+        schema: [
+          {
+            name: 'planet',
+            type: 'string',
+            def: 'Earth',
+            readOnly: true
+          },
+          {
+            name: 'moon',
+            type: 'string'
+          }
+        ]
+      }
+    ];
+
+    it('should keep read only values when editing a document', async function() {
+      const req = apos.task.getReq();
+      const schema = apos.schema.compose({
+        addFields: givenSchema
+      });
+      const home = await apos.page.find(req, { slug: '/' }).toObject();
+
+      const data = {
+        _relationship: [
+          {
+            ...home,
+            _fields: {
+              planet: 'Saturn',
+              moon: 'Titan'
+            }
+          }
+        ],
+        array: [
+          {
+            _id: 'Jupiter-Io',
+            moon: 'Io'
+          },
+          {
+            _id: 'Mars-Phobos',
+            moon: 'Phobos'
+          }
+        ],
+        object: {
+          _id: 'Neptune-Triton',
+          moon: 'Triton'
+        },
+        pageId: [ home._id ],
+        pageFields: {
+          [home._id]: {
+            planet: 'Saturn'
+          }
+        },
+        title: 'Sol'
+      };
+      const destination = {
+        _relationship: [
+          {
+            ...home,
+            _fields: {
+              planet: 'Saturn'
+            }
+          }
+        ],
+        array: [
+          {
+            _id: 'Jupiter-Io',
+            planet: 'Jupiter'
+          },
+          {
+            _id: 'Mars-Phobos',
+            planet: 'Mars'
+          }
+        ],
+        object: {
+          _id: 'Neptune-Triton',
+          planet: 'Neptune'
+        },
+        pageId: [ home._id ],
+        pageFields: {
+          [home._id]: {
+            planet: 'Saturn'
+          }
+        },
+        title: 'Default'
+      };
+      await apos.schema.convert(
+        req,
+        schema,
+        data,
+        destination
+      );
+
+      const actual = destination;
+      const expected = {
+        _relationship: [
+          {
+            _fields: {
+              planet: 'Saturn',
+              moon: 'Titan'
+            },
+            ...home
+          }
+        ],
+        array: [
+          {
+            _id: 'Jupiter-Io',
+            metaType: 'arrayItem',
+            moon: 'Io',
+            planet: 'Jupiter',
+            scopedArrayName: undefined
+          },
+          {
+            _id: 'Mars-Phobos',
+            metaType: 'arrayItem',
+            moon: 'Phobos',
+            planet: 'Mars',
+            scopedArrayName: undefined
+          }
+        ],
+        object: {
+          _id: 'Neptune-Triton',
+          metaType: 'objectItem',
+          moon: 'Triton',
+          planet: 'Neptune',
+          scopedObjectName: undefined
+        },
+        pageId: [ home._id ],
+        pageFields: {
+          [home._id]: {
+            planet: 'Saturn'
+          }
+        },
+        title: 'Sol'
+      };
+
+      assert.deepEqual(actual, expected);
+    });
+  });
+
   describe('field editPermission|viewPermission', function() {
     const schema = [
       {