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

package/content/plugins/crud/contentModelGroup.crud.js

@@ -0,0 +1,351 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModelGroupsCrud = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _fields = require("@commodo/fields");
+
+var _validation = require("@webiny/validation");
+
+var _mdbid = _interopRequireDefault(require("mdbid"));
+
+var utils = _interopRequireWildcard(require("../../../utils"));
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _CmsGroupPlugin = require("../CmsGroupPlugin");
+
+var _pubsub = require("@webiny/pubsub");
+
+var _beforeUpdate = require("./contentModelGroup/beforeUpdate");
+
+var _beforeCreate = require("./contentModelGroup/beforeCreate");
+
+var _beforeDelete = require("./contentModelGroup/beforeDelete");
+
+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; }
+
+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 CreateContentModelGroupModel = (0, _fields.withFields)({
+  name: (0, _fields.string)({
+    validation: _validation.validation.create("required,maxLength:100")
+  }),
+  slug: (0, _fields.string)({
+    validation: _validation.validation.create("maxLength:100")
+  }),
+  description: (0, _fields.string)({
+    validation: _validation.validation.create("maxLength:255")
+  }),
+  icon: (0, _fields.string)({
+    validation: _validation.validation.create("required,maxLength:255")
+  })
+})();
+const UpdateContentModelGroupModel = (0, _fields.withFields)({
+  name: (0, _fields.string)({
+    validation: _validation.validation.create("maxLength:100")
+  }),
+  description: (0, _fields.string)({
+    validation: _validation.validation.create("maxLength:255")
+  }),
+  icon: (0, _fields.string)({
+    validation: _validation.validation.create("maxLength:255")
+  })
+})();
+
+const createModelGroupsCrud = params => {
+  const {
+    getTenant,
+    getIdentity,
+    getLocale,
+    storageOperations,
+    context
+  } = params;
+
+  const getGroupsAsPlugins = () => {
+    const tenant = getTenant().id;
+    const locale = getLocale().code;
+    return context.plugins.byType(_CmsGroupPlugin.CmsGroupPlugin.type)
+    /**
+     * We need to filter out groups that are not for this tenant or locale.
+     * If it does not have tenant or locale define, it is for every locale and tenant
+     */
+    .filter(plugin => {
+      const {
+        tenant: t,
+        locale: l
+      } = plugin.contentModelGroup;
+
+      if (t && t !== tenant) {
+        return false;
+      } else if (l && l !== locale) {
+        return false;
+      }
+
+      return true;
+    }).map(plugin => {
+      return _objectSpread(_objectSpread({}, plugin.contentModelGroup), {}, {
+        tenant,
+        locale,
+        webinyVersion: context.WEBINY_VERSION
+      });
+    });
+  };
+
+  const checkPermissions = check => {
+    return utils.checkPermissions(context, "cms.contentModelGroup", {
+      rwd: check
+    });
+  };
+
+  const groupsGet = async id => {
+    const groupPlugin = getGroupsAsPlugins().find(group => group.id === id);
+
+    if (groupPlugin) {
+      return groupPlugin;
+    }
+
+    const tenant = getTenant().id;
+    const locale = getLocale().code;
+    let group = null;
+
+    try {
+      group = await storageOperations.groups.get({
+        tenant,
+        locale,
+        id
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message, ex.code || "GET_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+        id
+      }));
+    }
+
+    if (!group) {
+      throw new _handlerGraphql.NotFoundError(`Cms Group "${id}" was not found!`);
+    }
+
+    return _objectSpread(_objectSpread({}, group), {}, {
+      tenant: group.tenant || tenant,
+      locale: group.locale || locale
+    });
+  };
+
+  const groupsList = async params => {
+    const {
+      where
+    } = params || {};
+    const tenant = getTenant().id;
+    const locale = getLocale().code;
+
+    try {
+      const pluginsGroups = getGroupsAsPlugins();
+      const databaseGroups = await storageOperations.groups.list({
+        where: _objectSpread(_objectSpread({}, where || {}), {}, {
+          tenant: where ? where.tenant : tenant,
+          locale: where ? where.locale : locale
+        })
+      });
+      return pluginsGroups.concat(databaseGroups.map(group => {
+        return _objectSpread(_objectSpread({}, group), {}, {
+          tenant: group.tenant || tenant,
+          locale: group.locale || locale
+        });
+      }));
+    } catch (ex) {
+      throw new _error.default(ex.message, ex.code || "LIST_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+        where
+      }));
+    }
+  };
+
+  const onBeforeCreate = (0, _pubsub.createTopic)();
+  const onAfterCreate = (0, _pubsub.createTopic)();
+  const onBeforeUpdate = (0, _pubsub.createTopic)();
+  const onAfterUpdate = (0, _pubsub.createTopic)();
+  const onBeforeDelete = (0, _pubsub.createTopic)();
+  const onAfterDelete = (0, _pubsub.createTopic)();
+  /**
+   * We need to assign some default behaviors.
+   */
+
+  (0, _beforeCreate.assignBeforeGroupCreate)({
+    onBeforeCreate,
+    plugins: context.plugins,
+    storageOperations
+  });
+  (0, _beforeUpdate.assignBeforeGroupUpdate)({
+    onBeforeUpdate,
+    plugins: context.plugins
+  });
+  (0, _beforeDelete.assignBeforeGroupDelete)({
+    onBeforeDelete,
+    plugins: context.plugins,
+    storageOperations
+  });
+  return {
+    onBeforeGroupCreate: onBeforeCreate,
+    onAfterGroupCreate: onAfterCreate,
+    onBeforeGroupUpdate: onBeforeUpdate,
+    onAfterGroupUpdate: onAfterUpdate,
+    onBeforeGroupDelete: onBeforeDelete,
+    onAfterGroupDelete: onAfterDelete,
+    getGroup: async id => {
+      const permission = await checkPermissions("r");
+      const group = await groupsGet(id);
+      utils.checkOwnership(context, permission, group);
+      utils.validateGroupAccess(context, permission, group);
+      return group;
+    },
+    listGroups: async params => {
+      const {
+        where
+      } = params || {};
+      const {
+        tenant,
+        locale
+      } = where || {};
+      const permission = await checkPermissions("r");
+      const response = await groupsList(_objectSpread(_objectSpread({}, params || {}), {}, {
+        where: _objectSpread(_objectSpread({}, where || {}), {}, {
+          tenant: tenant || getTenant().id,
+          locale: locale || getLocale().code
+        })
+      }));
+      return response.filter(group => {
+        if (!utils.validateOwnership(context, permission, group)) {
+          return false;
+        }
+
+        return utils.validateGroupAccess(context, permission, group);
+      });
+    },
+    createGroup: async inputData => {
+      await checkPermissions("w");
+      const createdData = new CreateContentModelGroupModel().populate(_objectSpread(_objectSpread({}, inputData), {}, {
+        slug: inputData.slug ? utils.toSlug(inputData.slug) : ""
+      }));
+      await createdData.validate();
+      const input = await createdData.toJSON();
+      const identity = getIdentity();
+      const id = (0, _mdbid.default)();
+
+      const group = _objectSpread(_objectSpread({}, input), {}, {
+        id,
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        createdOn: new Date().toISOString(),
+        savedOn: new Date().toISOString(),
+        createdBy: {
+          id: identity.id,
+          displayName: identity.displayName,
+          type: identity.type
+        },
+        webinyVersion: context.WEBINY_VERSION
+      });
+
+      try {
+        await onBeforeCreate.publish({
+          group
+        });
+        const result = await storageOperations.groups.create({
+          input,
+          group
+        });
+        await onAfterCreate.publish({
+          group: result
+        });
+        return group;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not save data model group.", ex.code || "ERROR_ON_CREATE", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          group,
+          input
+        }));
+      }
+    },
+    updateGroup: async (id, inputData) => {
+      const permission = await checkPermissions("w");
+      const original = await groupsGet(id);
+      utils.checkOwnership(context, permission, original);
+      const input = new UpdateContentModelGroupModel().populate(inputData);
+      await input.validate();
+      const updatedDataJson = await input.toJSON({
+        onlyDirty: true
+      });
+      /**
+       * No need to continue if no values were changed
+       */
+
+      if (Object.keys(updatedDataJson).length === 0) {
+        return original;
+      }
+
+      const group = _objectSpread(_objectSpread(_objectSpread({}, original), updatedDataJson), {}, {
+        locale: getLocale().code,
+        tenant: getTenant().id,
+        savedOn: new Date().toISOString()
+      });
+
+      try {
+        await onBeforeUpdate.publish({
+          original,
+          group
+        });
+        const updatedGroup = await storageOperations.groups.update({
+          original,
+          group,
+          input
+        });
+        await onAfterUpdate.publish({
+          original,
+          group: updatedGroup
+        });
+        return updatedGroup;
+      } catch (ex) {
+        throw new _error.default(ex.message, ex.code || "UPDATE_ERROR", {
+          error: ex,
+          original,
+          group,
+          input
+        });
+      }
+    },
+    deleteGroup: async id => {
+      const permission = await checkPermissions("d");
+      const group = await groupsGet(id);
+      utils.checkOwnership(context, permission, group);
+
+      try {
+        await onBeforeDelete.publish({
+          group
+        });
+        await storageOperations.groups.delete({
+          group
+        });
+        await onAfterDelete.publish({
+          group
+        });
+      } catch (ex) {
+        throw new _error.default(ex.message, ex.code || "DELETE_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          id
+        }));
+      }
+
+      return true;
+    }
+  };
+};
+
+exports.createModelGroupsCrud = createModelGroupsCrud;

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

@@ -0,0 +1,6 @@
+import { ContextPlugin } from "@webiny/handler/plugins/ContextPlugin";
+import { CmsContext, HeadlessCmsStorageOperations } from "../../../types";
+export interface Params {
+    storageOperations: HeadlessCmsStorageOperations;
+}
+export declare const createContentCruds: (params: Params) => ContextPlugin<CmsContext>;

package/content/plugins/crud/index.js

@@ -0,0 +1,100 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createContentCruds = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+var _contentModelGroup = require("./contentModelGroup.crud");
+
+var _contentModel = require("./contentModel.crud");
+
+var _contentEntry = require("./contentEntry.crud");
+
+var _system = require("../../../plugins/crud/system.crud");
+
+var _settings = require("../../../plugins/crud/settings.crud");
+
+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 debug = process.env.DEBUG === "true";
+
+const createContentCruds = params => {
+  const {
+    storageOperations
+  } = params;
+  return new _ContextPlugin.ContextPlugin(async context => {
+    /**
+     * This should never happen in the actual project.
+     * It is to make sure that we load setup context before the CRUD init in our internal code.
+     */
+    if (!context.cms) {
+      debug && console.log(`Missing initial "cms" on the context. Make sure that you set it up before creating Content CRUDs.`);
+      return;
+    }
+
+    const getLocale = () => {
+      return context.i18n.getCurrentLocale();
+    };
+
+    const getIdentity = () => {
+      return context.security.getIdentity();
+    };
+
+    const getTenant = () => {
+      return context.tenancy.getCurrentTenant();
+    };
+
+    if (storageOperations.plugins && storageOperations.plugins.length > 0) {
+      context.plugins.register(storageOperations.plugins);
+    }
+
+    context.cms = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, context.cms), {}, {
+      storageOperations
+    }, (0, _system.createSystemCrud)({
+      context,
+      getTenant,
+      getIdentity,
+      storageOperations
+    })), (0, _settings.createSettingsCrud)({
+      context,
+      getTenant,
+      getLocale,
+      storageOperations
+    })), (0, _contentModelGroup.createModelGroupsCrud)({
+      context,
+      getTenant,
+      getLocale,
+      getIdentity,
+      storageOperations
+    })), (0, _contentModel.createModelsCrud)({
+      context,
+      getLocale,
+      getTenant,
+      getIdentity,
+      storageOperations
+    })), (0, _contentEntry.createContentEntryCrud)({
+      context,
+      getLocale,
+      getTenant,
+      getIdentity,
+      storageOperations
+    }));
+
+    if (!storageOperations.init) {
+      return;
+    }
+
+    await storageOperations.init(context.cms);
+  });
+};
+
+exports.createContentCruds = createContentCruds;

package/content/plugins/graphqlFields/boolean.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToGraphQLPlugin } from "../../../types";
+declare const plugin: CmsModelFieldToGraphQLPlugin;
+export default plugin;

package/content/plugins/graphqlFields/boolean.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+const createListFilters = ({
+  field
+}) => {
+  return `
+        ${field.fieldId}: Boolean
+        ${field.fieldId}_not: Boolean
+    `;
+};
+
+const plugin = {
+  name: "cms-model-field-to-graphql-boolean",
+  type: "cms-model-field-to-graphql",
+  fieldType: "boolean",
+  isSortable: true,
+  isSearchable: true,
+  read: {
+    createListFilters,
+
+    createGetFilters({
+      field
+    }) {
+      return `${field.fieldId}: Boolean`;
+    },
+
+    createTypeField({
+      field
+    }) {
+      if (field.multipleValues) {
+        return `${field.fieldId}: [Boolean]`;
+      }
+
+      return `${field.fieldId}: Boolean`;
+    }
+
+  },
+  manage: {
+    createListFilters,
+
+    createTypeField({
+      field
+    }) {
+      if (field.multipleValues) {
+        return field.fieldId + ": [Boolean]";
+      }
+
+      return field.fieldId + ": Boolean";
+    },
+
+    createInputField({
+      field
+    }) {
+      if (field.multipleValues) {
+        return field.fieldId + ": [Boolean]";
+      }
+
+      return field.fieldId + ": Boolean";
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/graphqlFields/datetime.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToGraphQLPlugin } from "../../../types";
+declare const plugin: CmsModelFieldToGraphQLPlugin;
+export default plugin;

package/content/plugins/graphqlFields/datetime.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const fieldGraphQLTypes = {
+  time: "Time",
+  dateTimeWithoutTimezone: "DateTime",
+  dateTimeWithTimezone: "DateTimeZ",
+  date: "Date"
+};
+
+const getFieldGraphQLType = field => {
+  const type = field.settings.type;
+
+  if (!type || !fieldGraphQLTypes[type]) {
+    return "DateTime";
+  }
+
+  return fieldGraphQLTypes[type];
+};
+
+const createListFilters = ({
+  field
+}) => {
+  return `
+        ${field.fieldId}: ${getFieldGraphQLType(field)}
+        ${field.fieldId}_not: ${getFieldGraphQLType(field)}
+        ${field.fieldId}_in: [${getFieldGraphQLType(field)}]
+        ${field.fieldId}_not_in: [${getFieldGraphQLType(field)}]
+        ${field.fieldId}_lt: ${getFieldGraphQLType(field)}
+        ${field.fieldId}_lte: ${getFieldGraphQLType(field)}
+        ${field.fieldId}_gt: ${getFieldGraphQLType(field)}
+        ${field.fieldId}_gte: ${getFieldGraphQLType(field)}
+    `;
+};
+
+const plugin = {
+  name: "cms-model-field-to-graphql-datetime",
+  type: "cms-model-field-to-graphql",
+  fieldType: "datetime",
+  isSortable: true,
+  isSearchable: true,
+  read: {
+    createListFilters,
+
+    createGetFilters({
+      field
+    }) {
+      return `${field.fieldId}: ${getFieldGraphQLType(field)}`;
+    },
+
+    createTypeField({
+      field
+    }) {
+      if (field.multipleValues) {
+        return `${field.fieldId}: [${getFieldGraphQLType(field)}]`;
+      }
+
+      return `${field.fieldId}: ${getFieldGraphQLType(field)}`;
+    }
+
+  },
+  manage: {
+    createListFilters,
+
+    createTypeField({
+      field
+    }) {
+      return `${field.fieldId}: ${getFieldGraphQLType(field)}`;
+    },
+
+    createInputField({
+      field
+    }) {
+      return `${field.fieldId}: ${getFieldGraphQLType(field)}`;
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/graphqlFields/file.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToGraphQLPlugin } from "../../../types";
+declare const plugin: CmsModelFieldToGraphQLPlugin;
+export default plugin;

package/content/plugins/graphqlFields/file.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const plugin = {
+  name: "cms-model-field-to-graphql-file",
+  type: "cms-model-field-to-graphql",
+  fieldType: "file",
+  isSortable: false,
+  isSearchable: false,
+  read: {
+    createTypeField({
+      field
+    }) {
+      if (field.multipleValues) {
+        return `${field.fieldId}: [String]`;
+      }
+
+      return `${field.fieldId}: String`;
+    }
+
+  },
+  manage: {
+    createTypeField({
+      field
+    }) {
+      if (field.multipleValues) {
+        return field.fieldId + ": [String]";
+      }
+
+      return field.fieldId + ": String";
+    },
+
+    createInputField({
+      field
+    }) {
+      if (field.multipleValues) {
+        return field.fieldId + ": [String]";
+      }
+
+      return field.fieldId + ": String";
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/graphqlFields/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("../../../types").CmsModelFieldToGraphQLPlugin[];
+export default _default;