apostrophe 3.58.0 → 3.59.0

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

@@ -374,6 +374,25 @@ module.exports = {
             // All fields should have an initial value in the database
             instance[field.name] = null;
           }
+          // A workaround specifically for areas. They must have a
+          // unique `_id` which makes `klona` a poor way to establish
+          // a default, and we don't pass functions in schema
+          // definitions, but top-level areas should always exist
+          // for reasonable results if the output of `newInstance`
+          // is saved without further editing on the front end
+          if ((field.type === 'area') && (!instance[field.name])) {
+            instance[field.name] = {
+              metaType: 'area',
+              items: [],
+              _id: self.apos.util.generateId()
+            };
+          }
+          // A workaround specifically for objects. These too need
+          // to have reasonable values in parked pages and any other
+          // situation where the data never passes through the UI
+          if ((field.type === 'object') && ((!instance[field.name]) || _.isEmpty(instance[field.name]))) {
+            instance[field.name] = self.newInstance(field.schema);
+          }
         }
         return instance;
       },
@@ -465,6 +484,78 @@ module.exports = {
         });
       },
 
+      async evaluateCondition(req, field, clause, destination, conditionalFields) {
+        for (const [ key, val ] of Object.entries(clause)) {
+          const destinationKey = _.get(destination, key);
+
+          if (key === '$or') {
+            const results = await Promise.all(val.map(clause => self.evaluateCondition(req, field, clause, destination, conditionalFields)));
+            const testResults = _.isPlainObject(results?.[0])
+              ? results.some(({ value }) => value)
+              : results.some((value) => value);
+            if (!testResults) {
+              return false;
+            }
+            continue;
+          } else if (val.$ne) {
+            // eslint-disable-next-line eqeqeq
+            if (val.$ne == destinationKey) {
+              return false;
+            }
+          }
+
+          // Handle external conditions:
+          //  - `if: { 'methodName()': true }`
+          //  - `if: { 'moduleName:methodName()': 'expected value' }`
+          // Checking if key ends with a closing parenthesis here to throw later if any argument is passed.
+          if (key.endsWith(')')) {
+            let externalConditionResult;
+
+            try {
+              externalConditionResult = await self.evaluateMethod(req, key, field.name, field.moduleName, destination._id);
+            } catch (error) {
+              throw self.apos.error('invalid', error.message);
+            }
+
+            if (externalConditionResult !== val) {
+              return false;
+            };
+
+            // Stop there, this is an external condition thus
+            // does not need to be checked against doc fields.
+            continue;
+          }
+
+          if (val.min && destinationKey < val.min) {
+            return false;
+          }
+          if (val.max && destinationKey > val.max) {
+            return false;
+          }
+
+          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) {
+            return false;
+          }
+        }
+
+        return true;
+      },
+
+      async isFieldRequired(req, field, destination) {
+        return field.requiredIf
+          ? await self.evaluateCondition(req, field, field.requiredIf, destination)
+          : field.required;
+      },
+
       // Convert submitted `data` object according to `schema`, sanitizing it
       // and populating the appropriate properties of `destination` with it.
       //
@@ -504,7 +595,16 @@ module.exports = {
 
           if (convert) {
             try {
-              await convert(req, field, data, destination);
+              const isRequired = await self.isFieldRequired(req, field, destination);
+              await convert(
+                req,
+                {
+                  ...field,
+                  required: isRequired
+                },
+                data,
+                destination
+              );
             } catch (error) {
               if (Array.isArray(error)) {
                 const invalid = self.apos.error('invalid', {
@@ -572,7 +672,7 @@ module.exports = {
           for (const field of schema) {
             if (field.if) {
               try {
-                const result = await evaluate(field.if, field.name, field.moduleName);
+                const result = await self.evaluateCondition(req, field, field.if, object, conditionalFields);
                 const previous = conditionalFields[field.name];
                 if (previous !== result) {
                   change = true;
@@ -598,55 +698,6 @@ module.exports = {
         } else {
           return true;
         }
-        async function evaluate(clause, fieldName, fieldModuleName) {
-          let result = true;
-          for (const [ key, val ] of Object.entries(clause)) {
-            if (key === '$or') {
-              const results = await Promise.all(val.map(clause => evaluate(clause, fieldName, fieldModuleName)));
-
-              if (!results.some(({ value }) => value)) {
-                result = false;
-                break;
-              }
-
-              // No need to go further here, the key is an "$or" condition...
-              continue;
-            }
-
-            // Handle external conditions:
-            //  - `if: { 'methodName()': true }`
-            //  - `if: { 'moduleName:methodName()': 'expected value' }`
-            // Checking if key ends with a closing parenthesis here to throw later if any argument is passed.
-            if (key.endsWith(')')) {
-              let externalConditionResult;
-
-              try {
-                externalConditionResult = await self.evaluateMethod(req, key, fieldName, fieldModuleName, object._id);
-              } catch (error) {
-                throw self.apos.error('invalid', error.message);
-              }
-
-              if (externalConditionResult !== val) {
-                result = false;
-                break;
-              };
-
-              // Stop there, this is an external condition thus
-              // does not need to be checked against doc fields.
-              continue;
-            }
-
-            if (conditionalFields[key] === false) {
-              result = false;
-              break;
-            }
-            if (val !== object[key]) {
-              result = false;
-              break;
-            }
-          }
-          return result;
-        }
       },
 
       async evaluateMethod(req, methodKey, fieldName, fieldModuleName, docId = null, optionalParenthesis = false) {
@@ -1246,6 +1297,9 @@ module.exports = {
         if (field.if && field.if.$or && !Array.isArray(field.if.$or)) {
           fail(`$or conditional must be an array of conditions. Current $or configuration: ${JSON.stringify(field.if.$or)}`);
         }
+        if (field.requiredIf && field.requiredIf.$or && !Array.isArray(field.requiredIf.$or)) {
+          fail(`$or conditional must be an array of conditions. Current $or configuration: ${JSON.stringify(field.requiredIf.$or)}`);
+        }
         if (!field.editPermission && field.permission) {
           field.editPermission = field.permission;
         }

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

@@ -65,13 +65,13 @@
                     :schema="schema"
                     :trigger-validation="triggerValidation"
                     :following-values="followingValues()"
-                    :conditional-fields="conditionalFields()"
+                    :conditional-fields="conditionalFields"
                     :value="currentDoc"
-                    @input="currentDocUpdate"
-                    @validate="triggerValidate"
                     :server-errors="currentDocServerErrors"
                     ref="schema"
                     :doc-id="docId"
+                    @input="currentDocUpdate"
+                    @validate="triggerValidate"
                   />
                 </div>
               </div>

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

@@ -1,7 +1,9 @@
 <template>
   <AposInputWrapper
-    :field="field" :error="effectiveError"
-    :uid="uid" :items="next"
+    :field="field"
+    :error="effectiveError"
+    :uid="uid"
+    :items="next"
     :display-options="displayOptions"
   >
     <template #additional>
@@ -54,19 +56,21 @@
             :id="listId"
           >
             <AposSchema
+              v-model="item.schemaInput"
               v-for="(item, index) in items"
-              :key="item._id"
-              :schema="schema"
               class="apos-input-array-inline-item"
               :class="item.open && !alwaysExpand ? 'apos-input-array-inline-item--active' : null"
-              v-model="item.schemaInput"
+              :key="item._id"
+              :schema="schema"
               :trigger-validation="triggerValidation"
               :generation="generation"
               :modifiers="['small', 'inverted']"
               :doc-id="docId"
               :following-values="getFollowingValues(item)"
-              :conditional-fields="conditionalFields(item.schemaInput?.data || {})"
+              :conditional-fields="itemsConditionalFields[item._id]"
               :field-style="field.style"
+              @input="setItemsConditionalFields(item._id)"
+              @validate="emitValidate()"
             >
               <template #before>
                 <component

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

@@ -11,14 +11,16 @@
       <div class="apos-input-object">
         <div class="apos-input-wrapper">
           <AposSchema
+            v-model="schemaInput"
+            ref="schema"
             :schema="schema"
             :trigger-validation="triggerValidation"
             :generation="generation"
             :doc-id="docId"
-            v-model="schemaInput"
-            :conditional-fields="conditionalFields(values)"
+            :conditional-fields="conditionalFields"
             :following-values="followingValuesWithParent"
-            ref="schema"
+            @input="evaluateConditions(values)"
+            @validate="emitValidate()"
           />
         </div>
       </div>

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

@@ -7,31 +7,36 @@
   >
     <template #body>
       <label
-        class="apos-choice-label" :for="getChoiceId(uid, choice.value)"
-        v-for="choice in choices" :key="choice.value"
+        class="apos-choice-label"
+        v-for="{label, value, tooltip} in choices"
+        :key="value"
+        :for="getChoiceId(uid, value)"
         :class="{'apos-choice-label--disabled': field.readOnly}"
       >
         <input
-          type="radio" class="apos-sr-only apos-input--choice apos-input--radio"
-          :value="JSON.stringify(choice.value)" :name="field.name"
-          :id="getChoiceId(uid, choice.value)"
-          :checked="next === choice.value"
+          type="radio"
+          class="apos-sr-only apos-input--choice apos-input--radio"
+          :id="getChoiceId(uid, value)"
+          :value="JSON.stringify(value)"
+          :name="field.name"
+          :checked="next === value"
           tabindex="1"
           :disabled="field.readOnly"
           @change="change($event.target.value)"
         >
         <span class="apos-input-indicator" aria-hidden="true">
           <component
-            :is="`${next === choice.value ? 'check-bold-icon' : 'span'}`"
-            :size="8" v-if="next === choice.value"
+            v-if="next === value"
+            :is="`${next === value ? 'check-bold-icon' : 'span'}`"
+            :size="8"
           />
         </span>
         <span class="apos-choice-label-text">
-          {{ $t(choice.label) }}
+          {{ $t(label) }}
           <AposIndicator
-            v-if="choice.tooltip"
+            v-if="tooltip"
             class="apos-choice-label-info"
-            :tooltip="choice.tooltip"
+            :tooltip="tooltip"
             :icon-size="14"
             icon="information-icon"
           />

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

@@ -39,7 +39,7 @@
         v-model="fieldState[field.name]"
         :is="fieldComponentMap[field.type]"
         :following-values="followingValues[field.name]"
-        :condition-met="conditionalFields[field.name]"
+        :condition-met="conditionalFields?.if[field.name]"
         :field="fields[field.name].field"
         :modifiers="fields[field.name].modifiers"
         :display-options="getDisplayOptions(field.name)"
@@ -49,6 +49,7 @@
         :ref="field.name"
         :generation="generation"
         @update-doc-data="onUpdateDocData"
+        @validate="emitValidate()"
       />
     </component>
     <slot name="after" />

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

@@ -7,15 +7,15 @@
           {{ $t(subform.label) }}
         </span>
         <AposSchema
-          :class="{ 'apos-subform__disabled': busy }"
+          ref="schema"
           data-apos-test="subformSchema"
+          :class="{ 'apos-subform__disabled': busy }"
           :data-apos-test-name="subform.name"
-          ref="schema"
           :trigger-validation="triggerValidation"
           :schema="schema"
           :value="docFields"
           :following-values="followingValues()"
-          :conditional-fields="conditionalFields()"
+          :conditional-fields="conditionalFields"
           :server-errors="serverErrors"
           :modifiers="['small']"
           @input="updateDocFields"

package/modules/@apostrophecms/schema/ui/apos/lib/conditionalFields.js

@@ -1,3 +1,9 @@
+// Supported field conditional types,
+// you can add a condition type to this array to make it available to the frontend
+const conditionTypes = [ 'if', 'requiredIf' ];
+export const getConditionTypesObject = () => Object
+  .fromEntries(conditionTypes.map((key) => ([ key, {} ])));
+
 // Evaluate the external conditions found in each field
 // via API calls - made in parallel for performance-
 // and store their result for reusability.
@@ -5,50 +11,51 @@
 // `docId` - the current docId (from prop or context)
 // `$t` - the i18n function (usually `this.$t`)
 export async function evaluateExternalConditions(schema, docId, $t) {
-  let externalConditionsResults = {};
+  const externalConditionsResults = getConditionTypesObject();
 
   for (const field of schema) {
-    if (field.if) {
-      const externalConditionKeys = Object
-        .entries(field.if)
-        .flatMap(getExternalConditionKeys)
-        .filter(Boolean);
-
-      const uniqExternalConditionKeys = [ ...new Set(externalConditionKeys) ];
-
-      let results = [];
-
-      try {
-        const promises = uniqExternalConditionKeys
-          .map(key => externalConditionsResults[key] !== undefined
-            ? null
-            : evaluateExternalCondition(key, field._id, docId)
-          )
+    for (const conditionType of conditionTypes) {
+      if (field[conditionType]) {
+        const externalConditionKeys = Object
+          .entries(field[conditionType])
+          .flatMap((entry) => getExternalConditionKeys(entry, conditionType))
           .filter(Boolean);
 
-        results = await Promise.all(promises);
-
-        externalConditionsResults = {
-          ...externalConditionsResults,
-          ...Object.fromEntries(results)
-        };
-      } catch (error) {
-        await apos.notify($t('apostrophe:errorEvaluatingExternalCondition', { name: field.name }), {
-          type: 'danger',
-          icon: 'alert-circle-icon',
-          dismiss: true,
-          localize: false
-        });
+        const uniqExternalConditionKeys = [ ...new Set(externalConditionKeys) ];
+
+        try {
+          const promises = uniqExternalConditionKeys
+            .map(key => (externalConditionsResults[conditionType][key] !== undefined
+              ? null
+              : evaluateExternalCondition(key, field._id, docId))
+            )
+            .filter(Boolean);
+
+          const results = await Promise.all(promises);
+
+          externalConditionsResults[conditionType] = {
+            ...externalConditionsResults[conditionType],
+            ...Object.fromEntries(results)
+          };
+        } catch (error) {
+          await apos.notify($t('apostrophe:errorEvaluatingExternalCondition', { name: field.name }), {
+            type: 'danger',
+            icon: 'alert-circle-icon',
+            dismiss: true,
+            localize: false
+          });
+        }
       }
     }
   }
   return externalConditionsResults;
 
-  function getExternalConditionKeys([ key, val ]) {
+  function getExternalConditionKeys([ key, val ], conditionType) {
     if (key === '$or') {
-      return val.flatMap(nested => Object.entries(nested).map(getExternalConditionKeys));
+      return val.flatMap(nested => Object.entries(nested)
+        .map((entry) => getExternalConditionKeys(entry, conditionType)));
     }
-    if (isExternalCondition(key)) {
+    if (isExternalCondition(key, conditionType)) {
       return key;
     }
     return null;
@@ -71,7 +78,7 @@ export async function evaluateExternalCondition(conditionKey, fieldId, docId) {
   return [ conditionKey, result ];
 }
 // Checking if key ends with a closing parenthesis here to throw later if any argument is passed.
-export function isExternalCondition(conditionKey) {
+export function isExternalCondition(conditionKey, conditionType) {
   if (!conditionKey.endsWith(')')) {
     return false;
   }
@@ -79,7 +86,7 @@ export function isExternalCondition(conditionKey) {
   const [ methodDefinition ] = conditionKey.split('(');
 
   if (!conditionKey.endsWith('()')) {
-    console.warn(`Warning in \`if\` definition: "${methodDefinition}()" should not be passed any argument.`);
+    console.warn(`Warning in \`${conditionType}\` definition: "${methodDefinition}()" should not be passed any argument.`);
   }
 
   return true;
@@ -103,56 +110,49 @@ export function isExternalCondition(conditionKey) {
 // `values` - the schema (all) values
 // `externalConditionsResults` - the results of the external conditions,
 // as returned by `evaluateExternalConditions`
-export function conditionalFields(
+export function getConditionalFields(
   schema,
   fields,
   values,
   externalConditionsResults
 ) {
-  const conditionalFields = {};
-
-  while (true) {
-    let change = false;
-    for (const field of schema) {
-      if (field.if) {
-        const result = evaluate(field.if);
-        const previous = conditionalFields[field.name];
-        if (previous !== result) {
-          change = true;
-        }
-        conditionalFields[field.name] = result;
+  const conditionalFields = getConditionTypesObject();
+
+  for (const field of schema) {
+    for (const conditionType of conditionTypes) {
+      if (field[conditionType]) {
+        const result = evaluate(field[conditionType], conditionType);
+        conditionalFields[conditionType][field.name] = result;
       }
     }
-    if (!change) {
-      break;
-    }
   }
 
-  const result = {};
+  const result = getConditionTypesObject();
+
   for (const field of fields) {
-    if (field.if) {
-      result[field.name] = conditionalFields[field.name];
+    for (const conditionType of conditionTypes) {
+      if (field[conditionType]) {
+        result[conditionType][field.name] = conditionalFields[conditionType][field.name];
+      }
     }
   }
+
   return result;
 
-  function evaluate(clause) {
-    let result = true;
+  function evaluate(clause, conditionType) {
     for (const [ key, val ] of Object.entries(clause)) {
       if (key === '$or') {
-        if (!val.some(clause => evaluate(clause))) {
-          result = false;
-          break;
+        if (!val.some(clause => evaluate(clause, conditionType))) {
+          return false;
         }
 
         // No need to go further here, the key is an "$or" condition...
         continue;
       }
 
-      if (isExternalCondition(key)) {
-        if (externalConditionsResults[key] !== val) {
-          result = false;
-          break;
+      if (isExternalCondition(key, conditionType)) {
+        if (externalConditionsResults[conditionType][key] !== val) {
+          return false;
         }
 
         // Stop there, this is an external condition thus
@@ -160,22 +160,27 @@ export function conditionalFields(
         continue;
       }
 
-      if (conditionalFields[key] === false) {
-        result = false;
-        break;
+      if (conditionalFields[conditionType][key] === false) {
+        return false;
       }
 
       const fieldValue = values[key];
 
       if (Array.isArray(fieldValue)) {
-        result = fieldValue.includes(val);
-        break;
+        return fieldValue.includes(val);
+      }
+
+      if (val.min && fieldValue < val.min) {
+        return false;
+      }
+      if (val.max && fieldValue > val.max) {
+        return false;
       }
+
       if (val !== fieldValue) {
-        result = false;
-        break;
+        return false;
       }
     }
-    return result;
+    return true;
   }
 }

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

@@ -20,6 +20,10 @@ export default {
       required: true,
       type: Object
     },
+    inputSchema: {
+      type: Array,
+      required: true
+    },
     serverError: {
       type: Object,
       default: null
@@ -80,7 +84,8 @@ export default {
     },
     schema() {
       // For AposDocEditorMixin
-      return (this.field.schema || []).filter(field => apos.schema.components.fields[field.type]);
+      return (this.inputSchema || this.field.schema || [])
+        .filter(field => apos.schema.components.fields[field.type]);
     },
     countLabel() {
       return this.$t('apostrophe:numberAdded', {
@@ -132,6 +137,8 @@ export default {
   },
   async mounted() {
     this.modal.active = true;
+    await this.evaluateExternalConditions();
+    this.evaluateConditions();
     if (this.next.length) {
       this.select(this.next[0]._id);
     }
@@ -179,6 +186,7 @@ export default {
     },
     currentDocUpdate(currentDoc) {
       this.currentDoc = currentDoc;
+      this.evaluateConditions();
     },
     async add() {
       if (await this.validate(true, false)) {