apostrophe 3.61.1 → 3.63.0

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

@@ -128,7 +128,7 @@ module.exports = {
     return {
       add: {
         new: {
-          canEdit: true,
+          canCreate: true,
           relationship: true,
           label: {
             key: 'apostrophe:newDocType',
@@ -156,7 +156,7 @@ module.exports = {
           description: 'apostrophe:publishingBatchConfirmation',
           confirmationButton: 'apostrophe:publishingBatchConfirmationButton'
         },
-        permission: 'edit'
+        permission: 'publish'
       },
       archive: {
         label: 'apostrophe:archive',
@@ -173,7 +173,7 @@ module.exports = {
           description: 'apostrophe:archivingBatchConfirmation',
           confirmationButton: 'apostrophe:archivingBatchConfirmationButton'
         },
-        permission: 'edit'
+        permission: 'delete'
       },
       restore: {
         label: 'apostrophe:restore',
@@ -670,10 +670,18 @@ module.exports = {
       },
       // Similar to insertDraftOf, invoked on first publication.
       insertPublishedOf(req, doc, published, options) {
+        // Check publish permission up front because we won't check it
+        // in insert
+        if (!self.apos.permission.can(req, 'publish', doc)) {
+          throw self.apos.error('forbidden');
+        }
         return self.insert(
           req.clone({ mode: 'published' }),
           published,
-          options
+          {
+            ...options,
+            permissions: false
+          }
         );
       },
       // Returns one editable piece matching the criteria, throws `notfound`
@@ -703,39 +711,6 @@ module.exports = {
       async delete(req, piece, options = {}) {
         return self.apos.doc.delete(req, piece, options);
       },
-      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]
-        }));
-      },
       // Enable inclusion of this type in sitewide search results
       searchDetermineTypes(types) {
         if (self.options.searchable !== false) {
@@ -850,7 +825,10 @@ module.exports = {
         return self.findOneForEditing(
           req,
           { _id: piece._id },
-          { attachments: true }
+          {
+            attachments: true,
+            permission: 'create'
+          }
         );
       },
 
@@ -1153,14 +1131,14 @@ module.exports = {
         browserOptions.batchOperations = self.checkBatchOperationsPermissions(req);
         browserOptions.utilityOperations = self.utilityOperations;
         browserOptions.insertViaUpload = self.options.insertViaUpload;
-        browserOptions.quickCreate = !self.options.singleton && self.options.quickCreate && self.apos.permission.can(req, 'edit', self.name, 'draft');
+        browserOptions.quickCreate = !self.options.singleton && self.options.quickCreate && browserOptions.canCreate;
         browserOptions.singleton = self.options.singleton;
         browserOptions.showCreate = !self.options.singleton && self.options.showCreate;
         browserOptions.showDismissSubmission = self.options.showDismissSubmission;
         browserOptions.showArchive = self.options.showArchive;
         browserOptions.showDiscardDraft = self.options.showDiscardDraft;
-        browserOptions.canEdit = self.apos.permission.can(req, 'edit', self.name, 'draft');
-        browserOptions.canPublish = self.apos.permission.can(req, 'edit', self.name, 'publish');
+        browserOptions.canDeleteDraft = self.apos.permission.can(req, 'delete', self.name, 'draft');
+
         _.defaults(browserOptions, {
           components: {}
         });

package/modules/@apostrophecms/piece-type/ui/apos/components/AposDocsManager.vue

@@ -30,7 +30,7 @@
         @click="saveRelationship"
       />
       <AposButton
-        v-else-if="moduleOptions.canEdit && moduleOptions.showCreate"
+        v-else-if="moduleOptions.canCreate && moduleOptions.showCreate"
         :label="{
           key: 'apostrophe:newDocType',
           type: $t(moduleOptions.label)
@@ -297,6 +297,14 @@ export default {
         withPublished: 1
       };
 
+      const type = this.relationshipField?.withType;
+      const isPage = apos.modules['@apostrophecms/page'].validPageTypes
+        .includes(type);
+
+      if (isPage) {
+        options.type = type;
+      }
+
       // Avoid undefined properties.
       const qs = Object.entries(options)
         .reduce((acc, [ key, val ]) => ({

package/modules/@apostrophecms/piece-type/ui/apos/components/AposUtilityOperations.vue

@@ -95,7 +95,13 @@ export default {
       }
     },
     setUtilityOperations () {
-      const { utilityOperations, canEdit } = this.moduleOptions;
+      const {
+        utilityOperations,
+        canPublish,
+        canEdit,
+        canArchive,
+        canCreate
+      } = this.moduleOptions;
 
       const operations = ((Array.isArray(utilityOperations) && utilityOperations) || []).filter(operation => {
         let ok = true;
@@ -106,9 +112,18 @@ export default {
             ok = !operation.relationship;
           }
         }
+        if (operation.canCreate) {
+          ok = ok && canCreate;
+        }
         if (operation.canEdit) {
           ok = ok && canEdit;
         }
+        if (operation.canArchive) {
+          ok = ok && canArchive;
+        }
+        if (operation.canPublish) {
+          ok = ok && canPublish;
+        }
         return ok;
       });
 

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

@@ -6,6 +6,84 @@ const cheerio = require('cheerio');
 
 module.exports = {
   extend: '@apostrophecms/widget-type',
+  cascades: [ 'linkFields' ],
+  linkFields(self, options) {
+    const linkWithType = (Array.isArray(options.linkWithType)
+      ? options.linkWithType
+      : [ options.linkWithType ]);
+
+    // Labels are not available at the time the schema is built,
+    // they are added on modulesRegistered.
+    const linkWithTypeChoices = linkWithType
+      .map(type => ({
+        label: type,
+        value: type
+      }))
+      .concat([
+        {
+          label: 'apostrophe:url',
+          value: '_url'
+        }
+      ]);
+
+    const linkWithTypeFields = linkWithType.reduce((fields, type) => {
+      const name = `_${type}`;
+      fields[name] = {
+        type: 'relationship',
+        label: type,
+        withType: type,
+        required: true,
+        max: 1,
+        browse: true,
+        if: {
+          linkTo: type
+        }
+      };
+      return fields;
+    }, {});
+    linkWithTypeFields.updateTitle = {
+      label: 'apostrophe:updateTitle',
+      type: 'boolean',
+      def: true,
+      if: {
+        $or: linkWithType.map(type => ({
+          linkTo: type
+        }))
+      }
+    };
+
+    return {
+      add: {
+        linkTo: {
+          label: 'apostrophe:linkTo',
+          type: 'select',
+          choices: linkWithTypeChoices,
+          required: true,
+          def: linkWithTypeChoices[0].value
+        },
+        ...linkWithTypeFields,
+        href: {
+          label: 'apostrophe:url',
+          type: 'string',
+          required: true,
+          if: {
+            linkTo: '_url'
+          }
+        },
+        target: {
+          label: 'apostrophe:linkTarget',
+          type: 'checkboxes',
+          htmlAttribute: 'target',
+          choices: [
+            {
+              label: 'apostrophe:openLinkInNewTab',
+              value: '_blank'
+            }
+          ]
+        }
+      }
+    };
+  },
   options: {
     icon: 'format-text-icon',
     label: 'apostrophe:richText',
@@ -270,6 +348,18 @@ module.exports = {
     'format-color-highlight-icon': 'FormatColorHighlight',
     'table-icon': 'Table'
   },
+  handlers(self) {
+    return {
+      'apostrophe:modulesRegistered': {
+        validateAndFixLinkWithTypes() {
+          self.validateAndFixLinkWithTypes();
+        },
+        composeLinkSchema() {
+          self.composeLinkSchema();
+        }
+      }
+    };
+  },
   methods(self) {
     return {
       // Return just the rich text of the widget, which may be undefined or null if it has not yet been edited
@@ -404,7 +494,9 @@ module.exports = {
               'href',
               'id',
               'name',
-              'target'
+              ...self.linkSchema
+                .filter(field => field.htmlAttribute)
+                .map(field => field.htmlAttribute)
             ]
           },
           alignLeft: {
@@ -675,6 +767,53 @@ module.exports = {
           }
         }
         return content;
+      },
+      // Validate the types provided for links, update labels derived from
+      // corresponding modules, as they are not available at the time
+      // the schema is generated.
+      validateAndFixLinkWithTypes() {
+        const linkWithType = (Array.isArray(self.options.linkWithType)
+          ? self.options.linkWithType
+          : [ self.options.linkWithType ]);
+
+        for (const type of linkWithType) {
+          if (!self.apos.modules[type]) {
+            throw new Error(
+              `The linkWithType option of rich text widget "${type}" must be a valid module type`
+            );
+          }
+
+          self.linkFields[`_${type}`].label = getLabel(type);
+          const choice = self.linkFields.linkTo.choices
+            .find(choice => choice.value === type);
+
+          choice.label = getLabel(type);
+        }
+
+        function getLabel(type) {
+          if ([ '@apostrophecms/any-page-type', '@apostrophecms/page' ].includes(type)) {
+            return 'apostrophe:page';
+          }
+          return self.apos.modules[type].options?.label ?? type;
+        }
+      },
+      // Compose and register the link schema.
+      composeLinkSchema() {
+        self.linkSchema = self.apos.schema.compose({
+          addFields: self.apos.schema.fieldsToArray(`Links ${self.__meta.name}`, self.linkFields),
+          arrangeFields: self.apos.schema.groupsToArray(self.linkFieldsGroups)
+        }, self);
+
+        self.apos.schema.validate(self.linkSchema, {
+          type: 'link',
+          subtype: self.__meta.name
+        });
+
+        // Don't allow htmlAttribute `href`, it's a special case.
+        const hrefField = self.linkSchema.find(field => field.htmlAttribute === 'href');
+        if (hrefField) {
+          throw new Error(`Field "${hrefField.name}" validation error: "htmlAttribute: href" is not allowed.`);
+        }
       }
     };
   },
@@ -739,6 +878,7 @@ module.exports = {
           // Not optional in presence of an insert menu, it's not acceptable UX without it
           placeholderTextWithInsertMenu: self.options.placeholderTextWithInsertMenu,
           linkWithType: Array.isArray(self.options.linkWithType) ? self.options.linkWithType : [ self.options.linkWithType ],
+          linkSchema: self.linkSchema,
           imageStyles: self.options.imageStyles
         };
         return finalData;

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

@@ -161,6 +161,14 @@ export default {
         return {};
       }
     },
+    // not used, but we need to keep it here to avoid
+    // an attribute [object Object]
+    meta: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
     docId: {
       type: String,
       required: false,

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

@@ -42,13 +42,6 @@ export default {
       active: false
     };
   },
-  watch: {
-    hasSelection(newVal, oldVal) {
-      if (!newVal) {
-        this.close();
-      }
-    }
-  },
   computed: {
     attributes() {
       return this.editor.getAttributes('image');
@@ -71,6 +64,13 @@ export default {
       return text !== '' || type?.name === 'image';
     }
   },
+  watch: {
+    hasSelection(newVal, oldVal) {
+      if (!newVal) {
+        this.close();
+      }
+    }
+  },
   methods: {
     click() {
       if (this.hasSelection) {

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

@@ -86,11 +86,11 @@ export default {
     }
   },
   data() {
-    const linkWithType = getOptions().linkWithType;
+
     return {
       generation: 1,
       href: null,
-      target: null,
+      // target: null,
       active: false,
       hasLinkOnOpen: false,
       triggerValidation: false,
@@ -98,73 +98,7 @@ export default {
         data: {}
       },
       formModifiers: [ 'small', 'margin-micro' ],
-      originalSchema: [
-        {
-          name: 'linkTo',
-          label: this.$t('apostrophe:linkTo'),
-          type: 'select',
-          def: linkWithType[0],
-          required: true,
-          choices: [
-            ...(linkWithType.map(type => {
-              return {
-                // Should already be localized server side
-                label: apos.modules[type].label,
-                value: type
-              };
-            })),
-            {
-              // TODO this needs i18n
-              label: this.$t('apostrophe:url'),
-              // Value that will never be a doc type
-              value: '_url'
-            }
-          ]
-        },
-        ...getOptions().linkWithType.map(type => ({
-          name: `_${type}`,
-          type: 'relationship',
-          label: apos.modules[type].label,
-          withType: type,
-          required: true,
-          max: 1,
-          browse: true,
-          if: {
-            linkTo: type
-          }
-        })),
-        {
-          name: 'updateTitle',
-          label: this.$t('apostrophe:updateTitle'),
-          type: 'boolean',
-          def: true,
-          if: {
-            $or: linkWithType.map(type => ({
-              linkTo: type
-            }))
-          }
-        },
-        {
-          name: 'href',
-          label: this.$t('apostrophe:url'),
-          type: 'string',
-          required: true,
-          if: {
-            linkTo: '_url'
-          }
-        },
-        {
-          name: 'target',
-          label: this.$t('apostrophe:linkTarget'),
-          type: 'checkboxes',
-          choices: [
-            {
-              label: this.$t('apostrophe:openLinkInNewTab'),
-              value: '_blank'
-            }
-          ]
-        }
-      ]
+      originalSchema: getOptions().linkSchema
     };
   },
   computed: {
@@ -186,6 +120,9 @@ export default {
     },
     schema() {
       return this.originalSchema;
+    },
+    schemaHtmlAttributes() {
+      return this.schema.filter(item => !!item.htmlAttribute);
     }
   },
   watch: {
@@ -249,10 +186,22 @@ export default {
         if (this.docFields.data.target && !this.docFields.data.href) {
           delete this.docFields.data.target;
         }
-        this.editor.commands.setLink({
-          target: this.docFields.data.target[0],
-          href: this.docFields.data.href
-        });
+
+        const attrs = this.schemaHtmlAttributes.reduce((acc, field) => {
+          const value = this.docFields.data[field.name];
+          if (field.type === 'checkboxes' && !value?.[0]) {
+            return acc;
+          }
+          if (field.type === 'boolean') {
+            acc[field.htmlAttribute] = value === true ? '' : null;
+            return acc;
+          }
+          acc[field.htmlAttribute] = Array.isArray(value) ? value[0] : value;
+          return acc;
+        }, {});
+        attrs.href = this.docFields.data.href;
+        this.editor.commands.setLink(attrs);
+
         this.close();
       });
     },
@@ -272,13 +221,23 @@ export default {
     },
     async populateFields() {
       try {
-        const attrs = this.attributes;
-        if (attrs.target) {
-          // checkboxes field expects an array
-          attrs.target = [ attrs.target ];
-        }
+        const attrs = { ...this.attributes };
         this.docFields.data = {};
         this.schema.forEach((item) => {
+          if (item.htmlAttribute && item.type === 'checkboxes') {
+            this.docFields.data[item.name] = attrs[item.htmlAttribute] ? [ attrs[item.htmlAttribute] ] : [];
+            return;
+          }
+          if (item.htmlAttribute && item.type === 'boolean') {
+            this.docFields.data[item.name] = attrs[item.htmlAttribute] === null
+              ? null
+              : (attrs[item.htmlAttribute] === '');
+            return;
+          }
+          if (item.htmlAttribute) {
+            this.docFields.data[item.name] = attrs[item.htmlAttribute] || '';
+            return;
+          }
           this.docFields.data[item.name] = attrs[item.name] || '';
         });
         const matches = this.docFields.data.href.match(/^#apostrophe-permalink-(.*)\?updateTitle=(\d)$/);
@@ -361,7 +320,7 @@ function getOptions() {
   }
 
   // special schema style for this use
-  .apos-link-control ::v-deep .apos-field--target {
+  .apos-link-control ::v-deep .apos-field--checkboxes {
     .apos-field__label {
       display: none;
     }

package/modules/@apostrophecms/rich-text-widget/ui/apos/tiptap-extensions/Link.js

@@ -8,6 +8,17 @@ export default (options) => {
         linkOnPaste: true,
         HTMLAttributes: {}
       };
+    },
+    addAttributes() {
+      return {
+        ...this.parent?.(),
+        ...apos.modules['@apostrophecms/rich-text-widget'].linkSchema
+          .filter(field => !!field.htmlAttribute)
+          .reduce((obj, field) => {
+            obj[field.htmlAttribute] = { default: field.def ?? null };
+            return obj;
+          }, {})
+      };
     }
   });
 };

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

@@ -28,6 +28,7 @@ module.exports = {
     self.fieldsById = {};
     self.arrayManagers = {};
     self.objectManagers = {};
+    self.fieldMetadataComponents = [];
 
     self.enableBrowserData();
 
@@ -1127,6 +1128,13 @@ module.exports = {
         return self.fieldTypes[typeName];
       },
 
+      addFieldMetadataComponent(namespace, component) {
+        self.fieldMetadataComponents.push({
+          name: component,
+          namespace
+        });
+      },
+
       // Given a schema and a query, add query builders to the query
       // for each of the fields in the schema, based on their field type,
       // if supported by the field type. If the field already has a
@@ -1762,6 +1770,7 @@ module.exports = {
         }
         browserOptions.action = self.action;
         browserOptions.components = { fields: fields };
+        browserOptions.fieldMetadataComponents = self.fieldMetadataComponents;
         return browserOptions;
       }
     };

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

@@ -192,6 +192,9 @@ module.exports = (self) => {
             query.and(criteria);
           }
         },
+        launder: function (s) {
+          return self.apos.launder.string(s);
+        },
         choices: async function () {
           return self.sortedDistinct(field.name, query);
         }
@@ -461,6 +464,7 @@ module.exports = (self) => {
                 $gte: value[0],
                 $lte: value[1]
               };
+              query.and(criteria);
             } else {
               criteria = {};
               criteria[field.name] = self.apos.launder.integer(value);
@@ -471,8 +475,14 @@ module.exports = (self) => {
         choices: async function () {
           return self.sortedDistinct(field.name, query);
         },
-        launder: function (s) {
-          return self.apos.launder.integer(s, null);
+        launder: function (value) {
+          const launderInteger = (v) => self.apos.launder.integer(v, null);
+
+          if (Array.isArray(value)) {
+            return value.map(launderInteger);
+          } else {
+            return launderInteger(value);
+          }
         }
       });
     }
@@ -505,6 +515,7 @@ module.exports = (self) => {
                 $gte: value[0],
                 $lte: value[1]
               };
+              query.and(criteria);
             } else {
               criteria = {};
               criteria[field.name] = self.apos.launder.float(value);
@@ -514,6 +525,15 @@ module.exports = (self) => {
         },
         choices: async function () {
           return self.sortedDistinct(field.name, query);
+        },
+        launder: function(value) {
+          const launderFloat = (v) => self.apos.launder.float(v, null);
+
+          if (Array.isArray(value)) {
+            return value.map(launderFloat);
+          } else {
+            return launderFloat(value);
+          }
         }
       });
     }

package/modules/@apostrophecms/schema/ui/apos/components/AposArrayEditor.vue

@@ -70,6 +70,7 @@
                     :following-values="followingValues()"
                     :conditional-fields="conditionalFields"
                     :value="currentDoc"
+                    :meta="currentDocMeta"
                     :server-errors="currentDocServerErrors"
                     ref="schema"
                     :doc-id="docId"

package/modules/@apostrophecms/schema/ui/apos/components/AposInputArea.vue

@@ -3,7 +3,9 @@
     :field="field"
     :error="effectiveError" :uid="uid"
     :display-options="displayOptions"
-    :modifiers="modifiers"
+    :modifiers="[...modifiers, 'full-width']"
+    :items="next.items"
+    :meta="areaMeta"
   >
     <template #body>
       <!-- data-apos-schema-area lets all the child areas know that this area is in a schema (which is in a modal)
@@ -18,6 +20,7 @@
           :is="editorComponent"
           :options="field.options"
           :items="next.items"
+          :meta="areaMeta"
           :choices="choices"
           :id="next._id"
           :field-id="field._id"