@webiny/api-headless-cms 5.18.3-beta.0 → 5.19.0-beta.2

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

@@ -0,0 +1,7 @@
+import { Topic } from "@webiny/pubsub/types";
+import { AfterEntryDeleteTopicParams, CmsContext } from "../../../../types";
+export interface Params {
+    context: CmsContext;
+    onAfterDelete: Topic<AfterEntryDeleteTopicParams>;
+}
+export declare const assignAfterEntryDelete: (params: Params) => void;

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

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignAfterEntryDelete = void 0;
+
+var _markLockedFields = require("./markLockedFields");
+
+const assignAfterEntryDelete = params => {
+  const {
+    context,
+    onAfterDelete
+  } = params;
+  onAfterDelete.subscribe(async params => {
+    const {
+      entry,
+      model
+    } = params;
+    const {
+      items
+    } = await context.cms.storageOperations.entries.list(model, {
+      where: {
+        entryId_not: entry.entryId,
+        latest: true
+      },
+      limit: 1
+    });
+
+    if (items.length > 0) {
+      return;
+    }
+
+    await (0, _markLockedFields.markUnlockedFields)({
+      context,
+      model
+    });
+  });
+};
+
+exports.assignAfterEntryDelete = assignAfterEntryDelete;

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

@@ -1,8 +1,12 @@
 import { CmsEntry, CmsModel, CmsContext } from "../../../../types";
-interface Args {
+export interface MarkLockedFieldsParams {
     model: CmsModel;
     entry: CmsEntry;
     context: CmsContext;
 }
-export declare const markLockedFields: ({ model, context }: Args) => Promise<void>;
-export {};
+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

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.markLockedFields = void 0;
+exports.markUnlockedFields = exports.markLockedFields = void 0;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
@@ -17,11 +17,15 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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 ({
-  model,
-  context
-}) => {
-  // If the model is registered via a plugin, we don't need do process anything.
+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)) {
@@ -80,4 +84,34 @@ const markLockedFields = async ({
   }
 };
 
-exports.markLockedFields = markLockedFields;
+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/referenceFieldsMapping.d.ts

@@ -0,0 +1,12 @@
+import { CmsContext, CmsModel } from "../../../../types";
+interface ReferenceObject {
+    id: string;
+    modelId: string;
+}
+interface Params {
+    context: CmsContext;
+    model: CmsModel;
+    input: Record<string, ReferenceObject | ReferenceObject[]>;
+}
+export declare const referenceFieldsMapping: (params: Params) => Promise<Record<string, any>>;
+export {};

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

@@ -0,0 +1,251 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.referenceFieldsMapping = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _dotProp = _interopRequireDefault(require("dot-prop"));
+
+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 buildReferenceFieldPaths = params => {
+  const {
+    fields,
+    parentPaths: initialParentPaths,
+    input
+  } = params;
+  const parentPaths = [].concat(initialParentPaths);
+  const isMultipleValues = Array.isArray(input);
+  return fields.filter(field => ["object", "ref"].includes(field.type)).reduce((collection, field) => {
+    /**
+     * First we check the ref field
+     */
+    if (field.type === "ref") {
+      const parentPathsValue = parentPaths.length > 0 ? `${parentPaths.join(".")}.` : "";
+
+      if (field.multipleValues) {
+        const inputValue = _dotProp.default.get(input, `${field.fieldId}`, []);
+
+        if (Array.isArray(inputValue) === false) {
+          return collection;
+        }
+
+        for (const key in inputValue) {
+          const path = `${parentPathsValue}${field.fieldId}.${key}`;
+          collection.push(path);
+        }
+
+        return collection;
+      }
+
+      if (isMultipleValues) {
+        for (const key in input) {
+          const path = `${parentPathsValue}${key}.${field.fieldId}`;
+          collection.push(path);
+        }
+
+        return collection;
+      }
+
+      collection.push(`${parentPathsValue}${field.fieldId}`);
+      return collection;
+    }
+    /**
+     * Then we move onto the object field
+     */
+
+
+    const parentPathsValue = parentPaths.length > 0 ? `${parentPaths.join(".")}.` : "";
+    /**
+     * This is if received input is array. We need to map key with fieldId at this point.
+     */
+
+    if (isMultipleValues) {
+      for (const key in input) {
+        const path = `${parentPathsValue}${key}.${field.fieldId}`;
+        collection.push(path);
+      }
+
+      return collection;
+    }
+
+    const objFieldPath = `${field.fieldId}`;
+
+    const objFieldInputValue = _dotProp.default.get(input, objFieldPath, []);
+    /**
+     * If field is multiple values one, we need to go through the input and use the existing keys.
+     */
+
+
+    if (field.multipleValues) {
+      if (Array.isArray(objFieldInputValue) === false) {
+        return collection;
+      }
+
+      for (const key in objFieldInputValue) {
+        const result = buildReferenceFieldPaths({
+          fields: field.settings.fields,
+          input: objFieldInputValue[key],
+          parentPaths: parentPaths.concat([field.fieldId, key])
+        });
+        collection.push(...result);
+      }
+
+      return collection;
+    }
+    /**
+     * Single value reference field.
+     */
+
+
+    const results = buildReferenceFieldPaths({
+      fields: field.settings.fields,
+      input: objFieldInputValue,
+      parentPaths: parentPaths.concat([field.fieldId])
+    });
+    return collection.concat(results);
+  }, []);
+};
+
+const referenceFieldsMapping = async params => {
+  const {
+    context,
+    model,
+    input
+  } = params;
+
+  let output = _objectSpread({}, input);
+
+  const referenceFieldPaths = buildReferenceFieldPaths({
+    fields: model.fields,
+    input,
+    parentPaths: []
+  });
+
+  if (referenceFieldPaths.length === 0) {
+    return output;
+  }
+
+  const referencesByModel = {};
+  const pathsByReferenceId = {};
+
+  for (const path of referenceFieldPaths) {
+    const ref = _dotProp.default.get(output, path);
+
+    if (!ref || !ref.id || !ref.modelId) {
+      continue;
+    }
+
+    if (!referencesByModel[ref.modelId]) {
+      referencesByModel[ref.modelId] = [];
+    }
+
+    referencesByModel[ref.modelId].push(ref.id);
+
+    if (!pathsByReferenceId[ref.id]) {
+      pathsByReferenceId[ref.id] = [];
+    }
+
+    pathsByReferenceId[ref.id].push(path);
+  }
+  /**
+   * Again, no point in going further.
+   */
+
+
+  if (Object.keys(referencesByModel).length === 0) {
+    return output;
+  }
+  /**
+   * Load all models and use only those that are used in reference.
+   */
+
+
+  const models = (await context.cms.listModels()).filter(model => {
+    const entries = referencesByModel[model.modelId];
+
+    if (Array.isArray(entries) === false || entries.length === 0) {
+      return false;
+    }
+
+    return true;
+  });
+  /**
+   * Check for any model existence, just in case.
+   */
+
+  if (models.length === 0) {
+    return output;
+  }
+  /**
+   * Load all the entries by their ID
+   */
+
+
+  const promises = models.map(model => {
+    return context.cms.getEntriesByIds(model, referencesByModel[model.modelId]);
+  });
+  const results = await Promise.all(promises);
+  const records = results.reduce((collection, entries) => {
+    for (const entry of entries) {
+      collection[entry.id] = entry;
+    }
+
+    return collection;
+  }, {});
+  /**
+   * Verify that all referenced entries actually exist.
+   */
+
+  for (const modelId in referencesByModel) {
+    const entries = referencesByModel[modelId];
+
+    for (const entry of entries) {
+      if (records[entry]) {
+        continue;
+      }
+
+      throw new _error.default(`Missing referenced entry with id "${entry}" in model "${modelId}".`, "ENTRY_NOT_FOUND", {
+        entry,
+        model: modelId
+      });
+    }
+  }
+  /**
+   * In the end, assign the entryId, id and model values to the output.
+   */
+
+
+  for (const id in pathsByReferenceId) {
+    const entry = records[id];
+    const paths = pathsByReferenceId[id];
+
+    if (!entry) {
+      throw new _error.default("Missing entry in records.", "ENTRY_ERROR", {
+        id,
+        paths
+      });
+    }
+
+    for (const path of paths) {
+      output = _dotProp.default.set(output, path, {
+        id: entry.id,
+        entryId: entry.entryId,
+        modelId: entry.modelId
+      });
+    }
+  }
+
+  return output;
+};
+
+exports.referenceFieldsMapping = referenceFieldsMapping;

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

@@ -1,6 +1,4 @@
 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";
@@ -10,8 +8,6 @@ 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;

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

@@ -29,6 +29,10 @@ var _utils2 = require("@webiny/utils");
 
 var _entryStorage = require("../utils/entryStorage");
 
+var _afterDelete = require("./contentEntry/afterDelete");
+
+var _referenceFieldsMapping = require("./contentEntry/referenceFieldsMapping");
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -79,20 +83,23 @@ const createEntryId = version => {
 };
 
 const increaseEntryIdVersion = id => {
-  if (id.includes("#") === false) {
+  const {
+    id: entryId,
+    version
+  } = (0, _utils2.parseIdentifier)(id);
+
+  if (!version) {
     throw new _error.default("Cannot increase version on the ID without the version part.", "WRONG_ID", {
       id
     });
   }
 
-  const [entryId, version] = id.split("#");
-  const ver = parseInt(version) + 1;
   return {
     entryId,
-    version: ver,
+    version: version + 1,
     id: (0, _utils2.createIdentifier)({
       id: entryId,
-      version: ver
+      version: version + 1
     })
   };
 };
@@ -101,8 +108,6 @@ const createContentEntryCrud = params => {
   const {
     storageOperations,
     context,
-    getTenant,
-    getLocale,
     getIdentity
   } = params;
   const onBeforeCreate = (0, _pubsub.createTopic)();
@@ -137,6 +142,10 @@ const createContentEntryCrud = params => {
     context,
     onBeforeUpdate
   });
+  (0, _afterDelete.assignAfterEntryDelete)({
+    context,
+    onAfterDelete
+  });
 
   const checkEntryPermissions = check => {
     return utils.checkPermissions(context, "cms.contentEntry", check);
@@ -183,8 +192,6 @@ const createContentEntryCrud = params => {
     });
     await utils.checkModelAccess(context, model);
     const entries = await storageOperations.entries.getByIds(model, {
-      tenant: getTenant().id,
-      locale: getLocale().code,
       ids
     });
     return entries.filter(entry => utils.validateOwnership(context, permission, entry));
@@ -246,8 +253,6 @@ const createContentEntryCrud = params => {
       });
       await utils.checkModelAccess(context, model);
       const entries = await storageOperations.entries.getPublishedByIds(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         ids
       });
       return entries.filter(entry => utils.validateOwnership(context, permission, entry));
@@ -262,16 +267,12 @@ const createContentEntryCrud = params => {
       });
       await utils.checkModelAccess(context, model);
       const entries = await storageOperations.entries.getLatestByIds(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         ids
       });
       return entries.filter(entry => utils.validateOwnership(context, permission, entry));
     },
     getEntryRevisions: async (model, entryId) => {
       return storageOperations.entries.getRevisions(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: entryId
       });
     },
@@ -313,8 +314,8 @@ const createContentEntryCrud = params => {
       const ownedBy = permission.own ? getIdentity().id : where.ownedBy;
 
       const listWhere = _objectSpread(_objectSpread({}, where), {}, {
-        tenant: where.tenant || getTenant().id,
-        locale: where.locale || getLocale().code
+        tenant: model.tenant,
+        locale: model.locale
       });
 
       if (ownedBy !== undefined) {
@@ -374,8 +375,13 @@ const createContentEntryCrud = params => {
        * Make sure we only work with fields that are defined in the model.
        */
 
-      const input = cleanInputData(model, inputData);
-      await (0, _entryDataValidation.validateModelEntryData)(context, model, input);
+      const initialInput = cleanInputData(model, inputData);
+      await (0, _entryDataValidation.validateModelEntryData)(context, model, initialInput);
+      const input = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+        context,
+        model,
+        input: initialInput
+      });
       const identity = context.security.getIdentity();
       const locale = context.cms.getLocale();
       const owner = {
@@ -448,15 +454,13 @@ const createContentEntryCrud = params => {
        * Entries are identified by a common parent ID + Revision number.
        */
 
-      const [uniqueId] = sourceId.split("#");
+      const {
+        id: uniqueId
+      } = (0, _utils2.parseIdentifier)(sourceId);
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: sourceId
       });
       const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: uniqueId
       });
 
@@ -470,9 +474,14 @@ const createContentEntryCrud = params => {
 
       const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
 
-      const values = _objectSpread(_objectSpread({}, originalEntry.values), input);
+      const initialValues = _objectSpread(_objectSpread({}, originalEntry.values), input);
 
-      await (0, _entryDataValidation.validateModelEntryData)(context, model, values);
+      await (0, _entryDataValidation.validateModelEntryData)(context, model, initialValues);
+      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+        context,
+        model,
+        input: initialValues
+      });
       utils.checkOwnership(context, permission, originalEntry);
       const latestEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, latestStorageEntry);
       const identity = context.security.getIdentity();
@@ -550,8 +559,6 @@ const createContentEntryCrud = params => {
        */
 
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id
       });
 
@@ -565,13 +572,21 @@ const createContentEntryCrud = params => {
 
       const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
       utils.checkOwnership(context, permission, originalEntry);
+
+      const initialValues = _objectSpread(_objectSpread({}, originalEntry.values), input);
+
+      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+        context,
+        model,
+        input: initialValues
+      });
       /**
        * We always send the full entry to the hooks and storage operations update.
        */
 
       const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
         savedOn: new Date().toISOString(),
-        values: _objectSpread(_objectSpread({}, originalEntry.values), input)
+        values
       });
 
       let storageEntry = undefined;
@@ -619,18 +634,12 @@ const createContentEntryCrud = params => {
         version
       } = (0, _utils2.parseIdentifier)(revisionId);
       const storageEntryToDelete = await storageOperations.entries.getRevisionById(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: revisionId
       });
       const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: entryId
       });
       const previousStorageEntry = await storageOperations.entries.getPreviousRevision(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         entryId,
         version
       });
@@ -698,8 +707,6 @@ const createContentEntryCrud = params => {
       });
       await utils.checkModelAccess(context, model);
       const storageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: entryId
       });
 
@@ -720,11 +727,7 @@ const createContentEntryCrud = params => {
         pw: "p"
       });
       await utils.checkModelAccess(context, model);
-      const tenant = getTenant().id;
-      const locale = getLocale().code;
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        tenant,
-        locale,
         id
       });
 
@@ -778,8 +781,6 @@ const createContentEntryCrud = params => {
         pw: "c"
       });
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id
       });
 
@@ -836,15 +837,13 @@ const createContentEntryCrud = params => {
       const permission = await checkEntryPermissions({
         pw: "r"
       });
-      const [entryId] = id.split("#");
+      const {
+        id: entryId
+      } = (0, _utils2.parseIdentifier)(id);
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id
       });
       const latestEntryRevision = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: entryId
       });
 
@@ -900,10 +899,10 @@ const createContentEntryCrud = params => {
       const permission = await checkEntryPermissions({
         pw: "u"
       });
-      const [entryId] = id.split("#");
+      const {
+        id: entryId
+      } = (0, _utils2.parseIdentifier)(id);
       const originalStorageEntry = await storageOperations.entries.getPublishedRevisionByEntryId(model, {
-        tenant: getTenant().id,
-        locale: getLocale().code,
         id: entryId
       });
 

package/content/plugins/crud/contentModel/beforeCreate.js

@@ -21,7 +21,7 @@ const disallowedModelIdList = ["contentModel", "contentModels", "contentModelGro
  * Add more if required.
  */
 
-const disallowedModelIdEndingList = ["Response", "List", "Meta", "Input", "Sorter"];
+const disallowedModelIdEndingList = ["Response", "List", "Meta", "Input", "Sorter", "RefType"];
 /**
  * Checks for the uniqueness of provided modelId, against the provided list of models.
  * It also takes plural / singular forms of the provided modelId into account.