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

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;