@webiny/api-headless-cms 0.0.0-mt-1

package/content/plugins/crud/contentEntry/entryDataValidation.js

@@ -0,0 +1,188 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateModelEntryData = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const validateValue = async (args, fieldValidators, value) => {
+  if (!fieldValidators) {
+    return null;
+  }
+
+  const {
+    validatorList,
+    context,
+    field,
+    contentModel
+  } = args;
+
+  try {
+    for (const fieldValidator of fieldValidators) {
+      const name = fieldValidator.name;
+      const validations = validatorList[name];
+
+      if (!validations || validations.length === 0) {
+        return `There are no "${name}" validators defined.`;
+      }
+
+      for (const validate of validations) {
+        const result = await validate({
+          value,
+          context,
+          validator: fieldValidator,
+          field,
+          contentModel
+        });
+
+        if (!result) {
+          return fieldValidator.message;
+        }
+      }
+    }
+  } catch (ex) {
+    return ex.message;
+  }
+
+  return null;
+};
+
+const validatePredefinedValue = (field, value) => {
+  const {
+    enabled = false,
+    values: predefinedValues = []
+  } = field.predefinedValues || {};
+
+  if (!enabled) {
+    return null;
+  } else if (Array.isArray(predefinedValues) === false || predefinedValues.length === 0) {
+    return "Missing predefined values to validate against.";
+  }
+
+  for (const predefinedValue of predefinedValues) {
+    // console.log(field.fieldId, predefinedValue.value, value, predefinedValue.value == value);
+    if (predefinedValue.value == value) {
+      return null;
+    }
+  }
+
+  return "Value sent does not match any of the available predefined values.";
+};
+/**
+ * When multiple values is selected we must run validations on the array containing the values
+ * And then on each value in the array
+ */
+
+
+const runFieldMultipleValuesValidations = async args => {
+  const {
+    field,
+    data
+  } = args;
+  const values = data[field.fieldId];
+
+  if (Array.isArray(values) === false) {
+    return `Value of the field "${field.fieldId}" is not an array.`;
+  }
+
+  const valuesError = await validateValue(args, field.listValidation || [], values);
+
+  if (valuesError) {
+    return valuesError;
+  }
+
+  for (const value of values) {
+    const valueError = await validateValue(args, field.validation || [], value);
+
+    if (valueError) {
+      return valueError;
+    }
+
+    const predefinedValueError = validatePredefinedValue(field, value);
+
+    if (predefinedValueError) {
+      return predefinedValueError;
+    }
+  }
+
+  return null;
+};
+/**
+ * Runs validation on given value.
+ */
+
+
+const runFieldValueValidations = async args => {
+  const {
+    data,
+    field
+  } = args;
+  const value = data[field.fieldId];
+  const error = await validateValue(args, field.validation, value);
+
+  if (error) {
+    return error;
+  }
+
+  return validatePredefinedValue(field, value);
+};
+
+const execValidation = async args => {
+  if (args.field.multipleValues) {
+    return await runFieldMultipleValuesValidations(args);
+  }
+
+  return await runFieldValueValidations(args);
+};
+
+const validateModelEntryData = async (context, contentModel, data) => {
+  /**
+   * To later simplify searching for the validations we map them to a name.
+   * @see CmsModelFieldValidatorPlugin.validator.validate
+   */
+  const validatorList = context.plugins.byType("cms-model-field-validator").reduce((acc, plugin) => {
+    const name = plugin.validator.name;
+
+    if (!acc[name]) {
+      acc[name] = [];
+    }
+
+    acc[name].push(plugin.validator.validate);
+    return acc;
+  }, {});
+  /**
+   * Loop through model fields and validate the corresponding data.
+   * Run validation only if the field has validation configured.
+   */
+
+  const invalidFields = [];
+
+  for (const field of contentModel.fields) {
+    const error = await execValidation({
+      contentModel,
+      validatorList,
+      field,
+      data,
+      context
+    });
+
+    if (!error) {
+      continue;
+    }
+
+    invalidFields.push({
+      fieldId: field.fieldId,
+      error
+    });
+  }
+
+  if (invalidFields.length > 0) {
+    throw new _error.default("Validation failed.", "VALIDATION_FAILED", invalidFields);
+  }
+};
+
+exports.validateModelEntryData = validateModelEntryData;

package/content/plugins/crud/contentEntry/markLockedFields.d.ts

@@ -0,0 +1,12 @@
+import { CmsEntry, CmsModel, CmsContext } from "../../../../types";
+export interface MarkLockedFieldsParams {
+    model: CmsModel;
+    entry: CmsEntry;
+    context: CmsContext;
+}
+export declare const markLockedFields: (params: MarkLockedFieldsParams) => Promise<void>;
+export interface MarkFieldsUnlockedParams {
+    context: CmsContext;
+    model: CmsModel;
+}
+export declare const markUnlockedFields: (params: MarkFieldsUnlockedParams) => Promise<void>;

package/content/plugins/crud/contentEntry/markLockedFields.js

@@ -0,0 +1,117 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.markUnlockedFields = exports.markLockedFields = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _CmsModelPlugin = require("../../CmsModelPlugin");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const markLockedFields = async params => {
+  const {
+    model,
+    context
+  } = params;
+  /**
+   * If the model is registered via a plugin, we don't need do process anything.
+   */
+
+  const plugins = context.plugins.byType(_CmsModelPlugin.CmsModelPlugin.type);
+
+  if (plugins.find(plugin => plugin.contentModel.modelId === model.modelId)) {
+    return;
+  }
+
+  const cmsLockedFieldPlugins = context.plugins.byType("cms-model-locked-field");
+  const existingLockedFields = model.lockedFields || [];
+  const lockedFields = [];
+
+  for (const field of model.fields) {
+    const alreadyLocked = existingLockedFields.some(lockedField => lockedField.fieldId === field.fieldId);
+
+    if (alreadyLocked) {
+      continue;
+    }
+
+    let lockedFieldData = {};
+    const lockedFieldPlugins = cmsLockedFieldPlugins.filter(pl => pl.fieldType === field.type);
+
+    for (const plugin of lockedFieldPlugins) {
+      if (typeof plugin.getLockedFieldData !== "function") {
+        continue;
+      }
+
+      const data = plugin.getLockedFieldData({
+        field
+      });
+      lockedFieldData = _objectSpread(_objectSpread({}, lockedFieldData), data);
+    }
+
+    lockedFields.push(_objectSpread({
+      fieldId: field.fieldId,
+      multipleValues: field.multipleValues,
+      type: field.type
+    }, lockedFieldData));
+  } // no need to update anything if no locked fields were added
+
+
+  if (lockedFields.length === 0) {
+    return;
+  }
+
+  const newLockedFields = existingLockedFields.concat(lockedFields);
+
+  try {
+    await context.cms.updateModelDirect({
+      original: model,
+      model: _objectSpread(_objectSpread({}, model), {}, {
+        lockedFields: newLockedFields
+      })
+    });
+    model.lockedFields = newLockedFields;
+  } catch (ex) {
+    throw new _error.default(`Could not update model "${model.modelId}" with new locked fields.`, "MODEL_LOCKED_FIELDS_UPDATE_FAILED", ex);
+  }
+};
+
+exports.markLockedFields = markLockedFields;
+
+const markUnlockedFields = async params => {
+  const {
+    context,
+    model
+  } = params;
+  /**
+   * If the model is registered via a plugin, we don't need do process anything.
+   */
+
+  const plugins = context.plugins.byType(_CmsModelPlugin.CmsModelPlugin.type);
+
+  if (plugins.find(plugin => plugin.contentModel.modelId === model.modelId)) {
+    return;
+  }
+
+  try {
+    await context.cms.updateModelDirect({
+      original: model,
+      model: _objectSpread(_objectSpread({}, model), {}, {
+        lockedFields: []
+      })
+    });
+    model.lockedFields = [];
+  } catch (ex) {
+    throw new _error.default(`Could not update model "${model.modelId}" with unlocked fields.`, "MODEL_UNLOCKED_FIELDS_UPDATE_FAILED", ex);
+  }
+};
+
+exports.markUnlockedFields = markUnlockedFields;

package/content/plugins/crud/contentEntry.crud.d.ts

@@ -0,0 +1,17 @@
+import { CmsEntryContext, CmsContext, HeadlessCmsStorageOperations } from "../../../types";
+import { I18NLocale } from "@webiny/api-i18n/types";
+import { Tenant } from "@webiny/api-tenancy/types";
+import { SecurityIdentity } from "@webiny/api-security/types";
+export declare const STATUS_DRAFT = "draft";
+export declare const STATUS_PUBLISHED = "published";
+export declare const STATUS_UNPUBLISHED = "unpublished";
+export declare const STATUS_CHANGES_REQUESTED = "changesRequested";
+export declare const STATUS_REVIEW_REQUESTED = "reviewRequested";
+export interface Params {
+    storageOperations: HeadlessCmsStorageOperations;
+    context: CmsContext;
+    getTenant: () => Tenant;
+    getLocale: () => I18NLocale;
+    getIdentity: () => SecurityIdentity;
+}
+export declare const createContentEntryCrud: (params: Params) => CmsEntryContext;