apostrophe 3.62.0 → 3.63.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 3.63.0 (2024-02-21)
+
+### Adds
+
+* Adds a `launder` method to the `slug` schema field query builder to allow for use in API queries.
+* Adds support for browsing specific pages in a relationship field when `withType` is set to a page type, like `@apostrophecms/home-page`, `default-page`, `article-page`...
+* Add support for `canCreate`, `canPreview` & `canShareDraft` in context operations conditions.
+* Add support for `canCreate`, `canEdit`, `canArchive` & `canPublish` in utility operations definitions.
+* Add `uponSubmit` requirement in the `@apostrophecms/login` module. `uponSubmit` requirements are checked each time the user submit the login form. See the documentation for more information.
+* Add field metadata feature, where every module can add metadata to fields via public API offered by `apos.doc.setMeta()`, `apos.doc.getMeta()`, `apos.doc.getMetaPath()` and `apos.doc.removeMeta()`. The metadata is stored in the database and can be used to store additional information about a field.
+* Add new `apos.schema.addFieldMetadataComponent(namespace, component)` method to allow adding custom components. They have access to the server-side added field metadata and can decide to show indicators on the admin UI fields. Currently supported fields are "string", "slug", "array", "object" and "area".
+
+### Fixes
+
+* When deleting a draft document, we remove related reverse IDs of documents having a relation to the deleted one.
+* Fix publishing or moving published page after a draft page on the same tree level to work as expected.
+* Check create permissions on create keyboard shortcut.
+* Copy requires create and edit permission.
+* Display a more informative error message when publishing a page because the parent page is not published and the current user has no permission to publish the parent page (while having permission to publish the current one).
+* The `content-changed` event for the submit draft action now uses a complete document.
+* Fix the context bar overlap on palette for non-admin users that have the permission to modify it.
+* Show widget icons in the editor area context menu.
+
+### Changes
+
+* Share Drafts modal styles made larger and it's toggle input has a larger hitbox.
+
 ## 3.62.0 (2024-01-25)
 
 ### Adds
@@ -11,6 +38,7 @@
 * Adds support in `can` and `criteria` methods for `create` and `delete`.
 * Changes support for image upload from `canEdit` to `canCreate`.
 * The media manager is compatible with per-doc permissions granted via the `@apostrophecms-pro/advanced-permission` module.
+* In inline arrays, the trash icon has been replaced by a close icon.
 
 ### Fixes
 
@@ -19,6 +47,7 @@
 * A user who has permission to `publish` a particular page should always be allowed to insert it into the
 published version of the site even if they could not otherwise insert a child of the published
 parent.
+* Display the "Browse" button in a relationship inside an inline array.
 
 ## 3.61.1 (2023-01-08)
 

package/modules/@apostrophecms/admin-bar/ui/apos/components/TheAposAdminBar.vue

@@ -16,7 +16,7 @@
           :items="userItems"
         />
       </div>
-      <TheAposContextBar @mounted="setSpacer" />
+      <TheAposContextBar @visibility-changed="setSpacer" />
       <component
         v-for="bar in bars"
         v-bind="bar.props || {}"

package/modules/@apostrophecms/admin-bar/ui/apos/components/TheAposContextBar.vue

@@ -42,7 +42,7 @@ import AposAdvisoryLockMixin from 'Modules/@apostrophecms/ui/mixins/AposAdvisory
 export default {
   name: 'TheAposContextBar',
   mixins: [ AposPublishMixin, AposAdvisoryLockMixin ],
-  emits: [ 'mounted' ],
+  emits: [ 'visibility-changed' ],
   data() {
     const query = apos.http.parseQuery(location.search);
     // If the URL references a draft, go into draft mode but then clean up the URL
@@ -137,6 +137,11 @@ export default {
   watch: {
     editMode(newVal) {
       window.apos.adminBar.editMode = newVal;
+    },
+    contextBarActive() {
+      this.$nextTick(() => {
+        this.$emit('visibility-changed');
+      });
     }
   },
   async mounted() {
@@ -173,9 +178,6 @@ export default {
     await this.updateDraftIsEditable();
     this.rememberLastBaseContext();
     this.published = await this.getPublished();
-    this.$nextTick(() => {
-      this.$emit('mounted');
-    });
 
     apos.util.onReadyAndRefresh(() => {
       if (window.apos.adminBar.scrollPosition) {

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

@@ -39,6 +39,7 @@
         :area-id="areaId"
         :key="widget._id"
         :widget="widget"
+        :meta="meta[widget._id]"
         :generation="generation"
         :i="i"
         :options="options"
@@ -111,6 +112,12 @@ export default {
         return [];
       }
     },
+    meta: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
     followingValues: {
       type: Object,
       default() {
@@ -379,7 +386,8 @@ export default {
           options: this.widgetOptionsByType(widget.type),
           type: widget.type,
           docId: this.docId,
-          parentFollowingValues: this.followingValues
+          parentFollowingValues: this.followingValues,
+          meta: this.meta[widget._id]?.aposMeta
         });
         apos.area.activeEditor = null;
         apos.bus.$off('apos-refreshing', cancelRefresh);

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

@@ -109,6 +109,7 @@
         :options="widgetOptions"
         :type="widget.type"
         :value="widget"
+        :meta="meta"
         @update="$emit('update', $event)"
         :doc-id="docId"
         :focused="isFocused"
@@ -124,6 +125,7 @@
         :area-field="field"
         :following-values="followingValuesWithParent"
         :value="widget"
+        :meta="meta"
         :foreign="foreign"
         @edit="$emit('edit', i);"
         :doc-id="docId"
@@ -193,6 +195,12 @@ export default {
         return {};
       }
     },
+    meta: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
     followingValues: {
       type: Object,
       default() {

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

@@ -35,12 +35,15 @@
         }"
         :modifiers="[ 'inline' ]"
       />
-      <!-- <AposButton
+      <AposButton
         v-bind="copyButton"
         v-if="!foreign"
         @click="$emit('copy')"
-        tooltip="Copy"
-      /> -->
+        :tooltip="{
+          content: 'apostrophe:copy',
+          placement: 'left'
+        }"
+      />
       <AposButton
         v-if="!foreign"
         :disabled="disabled || maxReached"

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

@@ -717,7 +717,6 @@ module.exports = {
       // This operation ignores the locale and mode of `req`
       // in favor of the actual document's locale and mode.
       async delete(req, doc, options = {}) {
-        options = options || {};
         const m = self.getManager(doc.type);
         await m.emit('beforeDelete', req, doc, options);
         await self.deleteBody(req, doc, options);
@@ -938,6 +937,252 @@ module.exports = {
           return self.db.insertOne(self.apos.util.clonePermanent(doc));
         });
       },
+      // Set meta data for a given field, that will be live under `aposMeta`
+      // doc property. It returns the path to the meta property withouth the
+      // key. See `getMetaPath` method for more information.
+      //
+      // Signature:
+      // `apos.doc.setMeta(doc, namespace, [subobject], ...pathComponents, key, value);`
+      // where arguments are as follows:
+      // - `doc`: the document to attach the meta property to.
+      // - `namespace`: the namespace of the meta property, by convention the
+      //   module name that is setting the meta property.
+      // - `subobject`: (optional) the name of the field subobject (e.g. array
+      //   item, widget, or any other field type object that have `_id` property).
+      //   This argument dictates how `pathComponents` are interpreted. If
+      //   `subobject` is not provided, `pathComponents` are interpreted as
+      //   a path starting from `doc`. If `subobject` is provided, `pathComponents`
+      //   are interpreted as a relative path from the `subobject` field.
+      // - `pathComponents`: the dot path to the field value. It can be any number
+      //   of strings with or without dot-separated components. If `subobject` is
+      //   provided, `pathComponents` are interpreted as a relative path from the
+      //   `subobject` field. If `subobject` is not provided, `pathComponents` are
+      //   interpreted as a top-level path. `pathComponents` is optional when
+      //   `subobject` field is provided. This way you can set a meta property
+      //   directly for e.g. array or widget field. See examples below.
+      // - `key`: the key of the meta property. Should be a string. Dot-path is
+      //   not supported, dots will be treated as part of the key. It's prefixed
+      //   automatically with the `namespace` (`namespace:key`) to avoid
+      //   conflicts with other modules.
+      // - `value`: the value of the meta property. Can be any JSON-serializable value.
+      //
+      // The document field metadata can be consumed by admin UI components. See
+      // `schema.addFieldMetadataComponent()` method for more information.
+      //
+      // Examples:
+      // - Set value of a top-level meta property of a generic field (e.g. string,
+      //   number, boolean, etc.):
+      // `apos.doc.setMeta(doc, 'my-module', 'title', 'myMetaKey', 'myMetaValue');`
+      //
+      // - Set value of a top-level meta property of an object field (can be
+      //   further nested):
+      // `apos.doc.setMeta(doc, 'my-module', 'address', 'city', 'myMetaKey', 'myMetaValue');`
+      //
+      // - Set value of a meta property of a field inside of an array field type:
+      // `apos.doc.setMeta(doc, 'my-module', arrayItemObject, 'city', 'myMetaKey', 'myMetaValue');`
+      //
+      // - Set value of a meta property of a rich text widget
+      // `apos.doc.setMeta(doc, 'my-module', widgetObject, 'myMetaKey', 'myMetaValue');`
+      //
+      // - Dots in the `key` are treated as part of the key, dots in `pathComponents`
+      //   are treated as dot-path and are not altered:
+      // `apos.doc.setMeta(doc, 'my-module', 'address', 'city.name', 'myMetaKey.with.dots', 'myMetaValue');`
+      //  will set `doc.aposMeta.address.aposMeta.city.name['my-module:myMetaKey.with.dots']: 'myMetaValue'`.
+      setMeta(doc, namespace, ...pathArgsWithKeyAndValue) {
+        if (!_.isPlainObject(doc) || !namespace) {
+          throw self.apos.error('invalid', 'Valid document and namespace are required.', {
+            cause: 'invalidArguments'
+          });
+        }
+
+        const pathArgs = [ ...pathArgsWithKeyAndValue ];
+        const value = pathArgs.pop();
+        const key = pathArgs.pop();
+
+        if (!key) {
+          throw self.apos.error('invalid', 'Key and value are required.', {
+            cause: 'invalidArguments'
+          });
+        }
+        if (typeof key !== 'string') {
+          throw self.apos.error('invalid', 'Key must be a string.', {
+            cause: 'invalidArguments'
+          });
+        }
+
+        const metaPath = self.getMetaPath(...pathArgs);
+        const metaPathFull = `aposMeta.${metaPath}`;
+        const nsKey = `${namespace}:${key}`;
+
+        const existingValue = _.get(doc, metaPathFull) || {};
+        existingValue[nsKey] = value;
+        _.set(doc, metaPathFull, existingValue);
+
+        return metaPath;
+      },
+      // Get meta data for a given field. It has exactly the same signature as
+      // `setMeta` method, except the last `value` argument.
+      getMeta(doc, namespace, ...pathArgsWithKey) {
+        if (!doc || !namespace) {
+          throw self.apos.error('invalid', 'Document and namespace are required.', {
+            cause: 'invalidArguments'
+          });
+        }
+
+        const pathArgs = [ ...pathArgsWithKey ];
+        const key = pathArgs.pop();
+
+        if (!key) {
+          throw self.apos.error('invalid', 'Key and value are required.', {
+            cause: 'invalidArguments'
+          });
+        }
+        if (typeof key !== 'string') {
+          throw self.apos.error('invalid', 'Key must be a string.', {
+            cause: 'invalidArguments'
+          });
+        }
+        const nsKey = `${namespace}:${key}`;
+
+        return _.get(
+          doc,
+          `aposMeta.${self.getMetaPath(...pathArgs)}`
+        )?.[nsKey];
+      },
+      // Remove meta data key for a given field. It has exactly the same signature as
+      // `setMeta` method, except the last `value` argument.
+      // A cleanup is performed to remove empty meta properties on each call.
+      removeMeta(doc, namespace, ...pathArgsWithKey) {
+        if (!doc || !namespace) {
+          throw self.apos.error('invalid', 'Document and namespace are required.', {
+            cause: 'invalidArguments'
+          });
+        }
+
+        const pathArgs = [ ...pathArgsWithKey ];
+        const key = pathArgs.pop();
+        const metaPath = self.getMetaPath(...pathArgs);
+        const metaPathFull = `aposMeta.${metaPath}`;
+
+        if (!_.has(doc, metaPathFull)) {
+          return;
+        }
+
+        if (!key) {
+          throw self.apos.error('invalid', 'Key and value are required.', {
+            cause: 'invalidArguments'
+          });
+        }
+        if (typeof key !== 'string') {
+          throw self.apos.error('invalid', 'Key must be a string.', {
+            cause: 'invalidArguments'
+          });
+        }
+        const nsKey = `${namespace}:${key}`;
+
+        const existingValue = _.get(doc, metaPathFull) || {};
+        delete existingValue[nsKey];
+        _.set(doc, metaPathFull, existingValue);
+
+        cleanup(doc.aposMeta, 'aposMeta');
+
+        return metaPath;
+
+        function cleanup(object, path) {
+          if (_.isEmpty(object)) {
+            _.unset(object, path);
+            return true;
+          }
+
+          for (const key of Object.keys(object)) {
+            if (key.includes(':')) {
+              return false;
+            }
+            if (!_.isPlainObject(object[key])) {
+              delete object[key];
+              continue;
+            }
+            if (!cleanup(object[key], `${path}.${key}`)) {
+              return false;
+            }
+
+            delete object[key];
+          }
+
+          return true;
+        }
+      },
+      // Get all meta keys for a given field. It has exactly the same signature as
+      // `setMeta` method, except no key/value should be provided.
+      getMetaKeys(doc, namespace, ...pathArgs) {
+        return Object.keys(
+          _.get(
+            doc,
+            `aposMeta.${self.getMetaPath(...pathArgs)}`
+          ) || {}
+        )
+          .filter(key => key.startsWith(`${namespace}:`))
+          .map(key => key.replace(`${namespace}:`, ''));
+      },
+      // Get the meta path for a given field.
+      // Signature:
+      // `apos.doc.getMetaPath([subobject,] ...pathComponents);`
+      // See `setMeta` for more information about `subobject` and `pathComponents` arguments.
+      //
+      // Returns the path to the meta property withouth the namespace and key.
+      // The returned path can be directly used to access or modify the meta property.
+      // It's supported by all meta API methods.
+      //
+      // Example:
+      // ```js
+      // const path = apos.doc.getMetaPath(subobject, 'address', 'city', 'name');
+      // apos.doc.setMeta(doc, ns, path, 'myMetaKey', 'myMetaValue');
+      // apos.doc.getMeta(doc, ns, path, 'myMetaKey');
+      // apos.doc.removeMeta(doc, ns, path, 'myMetaKey');
+      getMetaPath(...pathArgs) {
+        const args = pathArgs
+          .filter(arg => typeof arg !== 'undefined' && arg !== null);
+
+        let subObject;
+        if (_.isPlainObject(args[0])) {
+          subObject = args.shift();
+        }
+
+        if (args.some(arg => typeof arg !== 'string')) {
+          throw self.apos.error('invalid', 'All path components must be strings.', {
+            cause: 'invalidArguments'
+          });
+        }
+        const pathComponents = args.join('.aposMeta.');
+
+        if (!subObject && !pathComponents) {
+          throw self.apos.error(
+            'invalid',
+            'You must provide at least a "subobject" or at least one "pathComponent" string.',
+            { cause: 'invalidArguments' }
+          );
+        }
+
+        if (subObject && !subObject._id) {
+          throw self.apos.error(
+            'invalid',
+            'Provided subobject must have an _id property.',
+            { cause: 'subObjectNoId' }
+          );
+        }
+
+        if (!subObject) {
+          return pathComponents;
+        }
+
+        const metaPath = [];
+        metaPath.push(`@${subObject._id}`);
+        if (pathComponents) {
+          metaPath.push(`aposMeta.${pathComponents}`);
+        }
+
+        return metaPath.join('.');
+      },
 
       // Given either an id (as a string) or a criteria
       // object, return a criteria object.
@@ -1062,12 +1307,12 @@ module.exports = {
           _id: tabId,
           updatedAt: new Date()
         };
-        const result = await self.db.updateOne(criteria, {
+        const { result } = await self.db.updateOne(criteria, {
           $set: {
             advisoryLock: doc.advisoryLock
           }
         });
-        if (!result.result.nModified) {
+        if (!result.nModified) {
           const info = await self.db.findOne({
             _id
           }, {
@@ -1200,7 +1445,8 @@ module.exports = {
       // `conditions` may be an array containing one or multiple of these values:
       //
       // 'canPublish', 'canEdit', 'canDismissSubmission', 'canDiscardDraft',
-      // 'canLocalize', 'canArchive', 'canUnpublish', 'canCopy', 'canRestore'.
+      // 'canLocalize', 'canArchive', 'canUnpublish', 'canCopy', 'canRestore',
+      // 'canCreate', 'canPreview', 'canShareDraft'
 
       addContextOperation(operation) {
         if (arguments.length === 2) {
@@ -1230,7 +1476,10 @@ module.exports = {
             'canArchive',
             'canUnpublish',
             'canCopy',
-            'canRestore'
+            'canRestore',
+            'canCreate',
+            'canPreview',
+            'canShareDraft'
           ];
 
           if (!action || !context || !label || !modal) {

package/modules/@apostrophecms/doc/ui/apos/mixins/AposFieldMetaUtilsMixin.js

@@ -0,0 +1,93 @@
+// A mixin to be implemented by the registered external metadata components.
+// Registers the component props and provides useful util methods.
+
+import isPlainObject from 'lodash/isPlainObject';
+
+export default {
+  props: {
+    field: {
+      type: Object,
+      required: true
+    },
+    items: {
+      type: Array,
+      default() {
+        return [];
+      }
+    },
+    meta: {
+      type: Object,
+      default: () => ({})
+    },
+    namespace: {
+      type: String,
+      default: ''
+    },
+    metaRaw: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+
+  methods: {
+    /**
+     * Recursively search for a namespace and optional key. Optionally
+     * match a value if a key and value are provided. If no key is provided,
+     * the namespace is matched.
+     * Meta keys (inside `metaObject`) starting with '@' are ignored,
+     * if not explicitely set otherwise, as they are absolute paths
+     * and will be yielding false positives.
+     *
+     * @param {object} metaObject the meta object or any object inside it
+     * @param {string} namespace
+     * @param {string} [key] optional key to match
+     * @param {string|number|boolean} [value] optional value to match
+     * @param {boolean} [searchAbsolute] whether to search in absolute paths
+     * @returns {boolean}
+     */
+    hasMeta(metaObject, namespace, key, value, searchAbsolute = false) {
+      if (!metaObject) {
+        return false;
+      }
+      const theKey = `${namespace}:${key || ''}`;
+      const withValue = key && typeof value !== 'undefined' && value !== null;
+
+      for (const [ k, v ] of Object.entries(metaObject)) {
+        // Do not search in absolute paths as it will
+        // lead to false positives.
+        if (!searchAbsolute && k.startsWith('@')) {
+          continue;
+        }
+        if (evaluateKey(k)) {
+          return evaluateValue(v);
+        }
+
+        if (isPlainObject(v) && this.hasMeta(v, namespace, key, value)) {
+          return true;
+        }
+      }
+
+      return false;
+
+      function evaluateKey(aKey) {
+        if (key) {
+          return aKey === theKey;
+        }
+
+        return aKey.startsWith(theKey);
+      }
+
+      function evaluateValue(aValue) {
+        if (!withValue) {
+          return true;
+        }
+
+        if (isPlainObject(aValue)) {
+          return this.hasMeta(aValue, namespace, key, value);
+        }
+
+        return aValue === value;
+      }
+    }
+  }
+};

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

@@ -119,7 +119,7 @@ module.exports = {
             type: 'command-menu-manager-create-new'
           },
           permission: {
-            action: 'edit',
+            action: 'create',
             type: self.__meta.name
           },
           shortcut: 'C'
@@ -147,7 +147,7 @@ module.exports = {
             type: 'command-menu-manager-archive-selected'
           },
           permission: {
-            action: 'edit',
+            action: 'delete',
             type: self.__meta.name
           },
           shortcut: 'E'
@@ -328,6 +328,15 @@ module.exports = {
           }
         }
       },
+      afterDelete: {
+        async deleteRelatedReverseId(req, doc) {
+          // When deleting an unlocalized or draft document,
+          // we remove related reverse IDs of documents having a relation to the deleted one
+          if (!doc.aposMode || doc.aposMode === 'draft') {
+            await self.deleteRelatedReverseId(doc, true);
+          }
+        }
+      },
       afterRescue: {
         async revertDeduplication(req, doc) {
           const $set = await self.getRevertDeduplicationSet(req, doc);
@@ -371,18 +380,27 @@ module.exports = {
 
   methods(self) {
     return {
-      async updateCacheField(req, doc) {
-        const relatedDocsIds = self.getRelatedDocsIds(req, doc);
-
-        // - Remove current doc reference from docs that include it
-        // - Update these docs' cache field
-        await self.apos.doc.db.updateMany({
+      async deleteRelatedReverseId(doc, deleting = false) {
+        const locales = doc.aposLocale && deleting
+          ? [
+            doc.aposLocale.replace(':draft', ':published'),
+            doc.aposLocale.replace(':published', ':draft')
+          ]
+          : [ doc.aposLocale ];
+        return self.apos.doc.db.updateMany({
           relatedReverseIds: { $in: [ doc.aposDocId ] },
-          aposLocale: { $in: [ doc.aposLocale, null ] }
+          aposLocale: { $in: [ ...locales, null ] }
         }, {
           $pull: { relatedReverseIds: doc.aposDocId },
           $set: { cacheInvalidatedAt: doc.updatedAt }
         });
+      },
+      async updateCacheField(req, doc) {
+        const relatedDocsIds = self.getRelatedDocsIds(req, doc);
+
+        // - Remove current doc reference from docs that include it
+        // - Update these docs' cache field
+        await this.deleteRelatedReverseId(doc);
 
         if (relatedDocsIds.length) {
           // - Add current doc reference to related docs
@@ -423,7 +441,8 @@ module.exports = {
           label: 'apostrophe:shareDraft',
           modal: 'AposModalShareDraft',
           manuallyPublished: true,
-          hasUrl: true
+          hasUrl: true,
+          conditions: [ 'canShareDraft' ]
         });
       },
       getRelatedDocsIds(req, doc) {
@@ -1478,11 +1497,52 @@ module.exports = {
             return field.viewPermission && !self.apos.permission.can(req, field.viewPermission.action, field.viewPermission.type);
           });
 
+        if (doc.aposMeta && !self.apos.permission.can(req, 'edit', doc)) {
+          forbiddenSchemaFields.push({
+            name: 'aposMeta'
+          });
+        }
+
         forbiddenSchemaFields.forEach(field => {
           delete doc[field.name];
         });
 
         return doc;
+      },
+
+      composeFilters() {
+        self.filters = Object.keys(self.filters).map((key) => ({
+          name: key,
+          ...self.filters[key],
+          inputType: self.filters[key].inputType || 'select'
+        }));
+        // Add a null choice if not already added or set to `required`
+        self.filters.forEach((filter) => {
+          if (filter.choices) {
+            if (
+              !filter.required &&
+              filter.choices &&
+              !filter.choices.find((choice) => choice.value === null)
+            ) {
+              filter.def = null;
+              filter.choices.push({
+                value: null,
+                label: 'apostrophe:none'
+              });
+            }
+          } else {
+            // Dynamic choices from the REST API, but
+            // we need a label for "no opinion"
+            filter.nullLabel = 'Choose One';
+          }
+        });
+      },
+
+      composeColumns() {
+        self.columns = Object.keys(self.columns).map((key) => ({
+          name: key,
+          ...self.columns[key]
+        }));
       }
     };
   },