@webiny/api-headless-cms 5.19.1 → 5.20.0

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

@@ -276,6 +276,12 @@ const createContentEntryCrud = params => {
         id: entryId
       });
     },
+
+    /**
+     * TODO determine if this method is required at all.
+     *
+     * @internal
+     */
     getEntry: async (model, params) => {
       await checkEntryPermissions({
         rwd: "r"
@@ -300,17 +306,40 @@ const createContentEntryCrud = params => {
 
       return items[0];
     },
+
+    /**
+     * @description Should not be used directly. Internal use only!
+     *
+     * @internal
+     */
     listEntries: async (model, params) => {
       const permission = await checkEntryPermissions({
         rwd: "r"
       });
       await utils.checkModelAccess(context, model);
-      const where = params.where || {};
+      const {
+        where
+      } = params;
+      /**
+       * Where must contain either latest or published keys.
+       * We cannot list entries without one of those
+       */
+
+      if (where.latest && where.published) {
+        throw new _error.default("Cannot list entries that are both published and latest.", "LIST_ENTRIES_ERROR", {
+          where
+        });
+      } else if (!where.latest && !where.published) {
+        throw new _error.default("Cannot list entries if we do not have latest or published defined.", "LIST_ENTRIES_ERROR", {
+          where
+        });
+      }
       /**
        * Possibly only get records which are owned by current user.
        * Or if searching for the owner set that value - in the case that user can see other entries than their own.
        */
 
+
       const ownedBy = permission.own ? getIdentity().id : where.ownedBy;
 
       const listWhere = _objectSpread(_objectSpread({}, where), {}, {

package/content/plugins/crud/contentModel/beforeCreate.d.ts

@@ -3,7 +3,12 @@ import { Topic } from "@webiny/pubsub/types";
 import { PluginsContainer } from "@webiny/plugins";
 export interface Params {
     onBeforeCreate: Topic<BeforeModelCreateTopicParams>;
+    onBeforeCreateFrom: Topic<BeforeModelCreateTopicParams>;
     storageOperations: HeadlessCmsStorageOperations;
     plugins: PluginsContainer;
 }
+/**
+ * We attach both on before create and createFrom events here.
+ * Callables are identical.
+ */
 export declare const assignBeforeModelCreate: (params: Params) => void;

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

@@ -103,13 +103,11 @@ const getModelId = model => {
   });
 };
 
-const assignBeforeModelCreate = params => {
-  const {
-    onBeforeCreate,
-    storageOperations,
-    plugins
-  } = params;
-  onBeforeCreate.subscribe(async params => {
+const createOnBeforeCb = ({
+  plugins,
+  storageOperations
+}) => {
+  return async params => {
     const {
       model
     } = params;
@@ -140,7 +138,28 @@ const assignBeforeModelCreate = params => {
     checkModelIdEndingAllowed(modelId);
     checkModelIdUniqueness(modelIdList, modelId);
     model.modelId = modelId;
-  });
+  };
+};
+
+/**
+ * We attach both on before create and createFrom events here.
+ * Callables are identical.
+ */
+const assignBeforeModelCreate = params => {
+  const {
+    onBeforeCreate,
+    onBeforeCreateFrom,
+    storageOperations,
+    plugins
+  } = params;
+  onBeforeCreate.subscribe(createOnBeforeCb({
+    storageOperations,
+    plugins
+  }));
+  onBeforeCreateFrom.subscribe(createOnBeforeCb({
+    storageOperations,
+    plugins
+  }));
 };
 
 exports.assignBeforeModelCreate = assignBeforeModelCreate;

package/content/plugins/crud/contentModel/models.d.ts

@@ -1,3 +1,4 @@
 export declare const CreateContentModelModel: any;
+export declare const CreateContentModelModelFrom: any;
 export declare const ContentModelFieldModel: any;
 export declare const UpdateContentModelModel: any;

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

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.UpdateContentModelModel = exports.CreateContentModelModel = exports.ContentModelFieldModel = void 0;
+exports.UpdateContentModelModel = exports.CreateContentModelModelFrom = exports.CreateContentModelModel = exports.ContentModelFieldModel = void 0;
 
 var _validation = require("@webiny/validation");
 
@@ -36,6 +36,24 @@ const CreateContentModelModel = (0, _fields.withFields)({
   })
 })();
 exports.CreateContentModelModel = CreateContentModelModel;
+const CreateContentModelModelFrom = (0, _fields.withFields)({
+  name: (0, _fields.string)({
+    validation: requiredShortString
+  }),
+  modelId: (0, _fields.string)({
+    validation: shortString
+  }),
+  description: (0, _fields.string)({
+    validation: shortString
+  }),
+  group: (0, _fields.string)({
+    validation: requiredShortString
+  }),
+  locale: (0, _fields.string)({
+    validation: shortString
+  })
+})();
+exports.CreateContentModelModelFrom = CreateContentModelModelFrom;
 const RendererModel = (0, _fields.withFields)({
   name: (0, _fields.string)({
     validation: requiredShortString

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

@@ -185,6 +185,8 @@ const createModelsCrud = params => {
 
   const onBeforeCreate = (0, _pubsub.createTopic)();
   const onAfterCreate = (0, _pubsub.createTopic)();
+  const onBeforeCreateFrom = (0, _pubsub.createTopic)();
+  const onAfterCreateFrom = (0, _pubsub.createTopic)();
   const onBeforeUpdate = (0, _pubsub.createTopic)();
   const onAfterUpdate = (0, _pubsub.createTopic)();
   const onBeforeDelete = (0, _pubsub.createTopic)();
@@ -195,6 +197,7 @@ const createModelsCrud = params => {
 
   (0, _beforeCreate.assignBeforeModelCreate)({
     onBeforeCreate,
+    onBeforeCreateFrom,
     plugins: context.plugins,
     storageOperations
   });
@@ -223,6 +226,8 @@ const createModelsCrud = params => {
   return {
     onBeforeModelCreate: onBeforeCreate,
     onAfterModelCreate: onAfterCreate,
+    onBeforeModelCreateFrom: onBeforeCreateFrom,
+    onAfterModelCreateFrom: onAfterCreateFrom,
     onBeforeModelUpdate: onBeforeUpdate,
     onAfterModelUpdate: onAfterUpdate,
     onBeforeModelDelete: onBeforeDelete,
@@ -259,8 +264,10 @@ const createModelsCrud = params => {
       }
 
       const identity = getIdentity();
-
-      const model = _objectSpread(_objectSpread({}, input), {}, {
+      const model = {
+        name: input.name,
+        description: input.description,
+        modelId: input.modelId,
         titleFieldId: "id",
         locale: getLocale().code,
         tenant: getTenant().id,
@@ -279,8 +286,7 @@ const createModelsCrud = params => {
         lockedFields: [],
         layout: [],
         webinyVersion: context.WEBINY_VERSION
-      });
-
+      };
       await onBeforeCreate.publish({
         model,
         input
@@ -334,6 +340,83 @@ const createModelsCrud = params => {
       return resultModel;
     },
 
+    async createModelFrom(modelId, data) {
+      await checkModelPermissions("w");
+      /**
+       * Get a model record; this will also perform ownership validation.
+       */
+
+      const original = await get(modelId);
+      const createdData = new _models.CreateContentModelModelFrom().populate({
+        name: data.name,
+        modelId: data.modelId,
+        description: data.description || original.description,
+        group: data.group,
+        locale: data.locale
+      });
+      await createdData.validate();
+      const input = await createdData.toJSON();
+      const locale = await context.i18n.getLocale(input.locale || original.locale);
+
+      if (!locale) {
+        throw new _handlerGraphql.NotFoundError(`There is no locale "${input.locale}".`);
+      }
+      /**
+       * Use storage operations directly because we cannot get group from different locale via context methods.
+       */
+
+
+      const group = await context.cms.storageOperations.groups.get({
+        id: input.group,
+        tenant: original.tenant,
+        locale: locale.code
+      });
+
+      if (!group) {
+        throw new _handlerGraphql.NotFoundError(`There is no group "${input.group}".`);
+      }
+
+      const identity = getIdentity();
+
+      const model = _objectSpread(_objectSpread({}, original), {}, {
+        locale: locale.code,
+        group: {
+          id: group.id,
+          name: group.name
+        },
+        name: input.name,
+        modelId: input.modelId,
+        description: input.description,
+        createdBy: {
+          id: identity.id,
+          displayName: identity.displayName,
+          type: identity.type
+        },
+        createdOn: new Date().toISOString(),
+        savedOn: new Date().toISOString(),
+        lockedFields: [],
+        webinyVersion: context.WEBINY_VERSION
+      });
+
+      await onBeforeCreateFrom.publish({
+        model,
+        original,
+        input
+      });
+      const createdModel = await storageOperations.models.create({
+        input,
+        model
+      });
+      loaders.listModels.clearAll();
+      await updateManager(context, model);
+      await onAfterCreateFrom.publish({
+        input,
+        original,
+        model: createdModel
+      });
+      return createdModel;
+    },
+
     async updateModel(modelId, inputData) {
       await checkModelPermissions("w"); // Get a model record; this will also perform ownership validation.
 
@@ -348,25 +431,30 @@ const createModelsCrud = params => {
         return {};
       }
 
+      let group = {
+        id: original.group.id,
+        name: original.group.name
+      };
+
       if (input.group) {
         context.security.disableAuthorization();
-        const group = await context.cms.getGroup(input.group);
+        const groupData = await context.cms.getGroup(input.group);
         context.security.enableAuthorization();
 
-        if (!group) {
+        if (!groupData) {
           throw new _handlerGraphql.NotFoundError(`There is no group "${input.group}".`);
         }
 
-        input.group = {
-          id: group.id,
-          name: group.name
+        group = {
+          id: groupData.id,
+          name: groupData.name
         };
       }
 
       const modelFields = await (0, _createFieldModels.createFieldModels)(original, inputData);
-      (0, _validateLayout.validateLayout)(input, modelFields);
 
       const model = _objectSpread(_objectSpread(_objectSpread({}, original), input), {}, {
+        group,
         tenant: original.tenant || getTenant().id,
         locale: original.locale || getLocale().code,
         webinyVersion: context.WEBINY_VERSION,
@@ -374,6 +462,7 @@ const createModelsCrud = params => {
         savedOn: new Date().toISOString()
       });
 
+      (0, _validateLayout.validateLayout)(model, modelFields);
       await onBeforeUpdate.publish({
         input,
         original,

package/content/plugins/graphqlFields/object.js

@@ -27,6 +27,11 @@ const typeFromField = ({
   const mTypeName = (0, _createTypeName.createManageTypeName)(typeName); // `field` is an "object" field
 
   const fields = field.settings.fields;
+
+  if (!fields || fields.length === 0) {
+    return null;
+  }
+
   const fieldTypeName = `${mTypeName}_${(0, _upperFirst.default)(field.fieldId)}`;
   const typeFields = [];
   const nestedTypes = []; // Once the loop below starts, we'll be executing a recursive "object" type generation.
@@ -84,16 +89,22 @@ const plugin = {
       model,
       fieldTypePlugins
     }) {
-      const {
-        fieldType,
-        typeDefs
-      } = typeFromField({
+      const result = typeFromField({
         typeOfType: "type",
         model,
         type: "read",
         field,
         fieldTypePlugins
       });
+
+      if (!result) {
+        return null;
+      }
+
+      const {
+        fieldType,
+        typeDefs
+      } = result;
       return {
         fields: `${field.fieldId}: ${field.multipleValues ? `[${fieldType}!]` : fieldType}`,
         typeDefs
@@ -105,13 +116,18 @@ const plugin = {
       createFieldResolvers,
       graphQLType
     }) {
+      if (!field.settings.fields || field.settings.fields.length === 0) {
+        return false;
+      }
+
       const fieldType = `${graphQLType}_${(0, _upperFirst.default)(field.fieldId)}`;
+      const typeResolvers = createFieldResolvers({
+        graphQLType: fieldType,
+        fields: field.settings.fields
+      });
       return {
         resolver: null,
-        typeResolvers: createFieldResolvers({
-          graphQLType: fieldType,
-          fields: field.settings.fields
-        })
+        typeResolvers: typeResolvers || {}
       };
     }
 
@@ -122,16 +138,22 @@ const plugin = {
       field,
       fieldTypePlugins
     }) {
-      const {
-        fieldType,
-        typeDefs
-      } = typeFromField({
+      const result = typeFromField({
         typeOfType: "type",
         model,
         type: "manage",
         field,
         fieldTypePlugins
       });
+
+      if (!result) {
+        return null;
+      }
+
+      const {
+        fieldType,
+        typeDefs
+      } = result;
       return {
         fields: `${field.fieldId}: ${field.multipleValues ? `[${fieldType}!]` : fieldType}`,
         typeDefs
@@ -143,16 +165,22 @@ const plugin = {
       field,
       fieldTypePlugins
     }) {
-      const {
-        fieldType,
-        typeDefs
-      } = typeFromField({
+      const result = typeFromField({
         typeOfType: "input",
         model,
         type: "manage",
         field,
         fieldTypePlugins
       });
+
+      if (!result) {
+        return null;
+      }
+
+      const {
+        fieldType,
+        typeDefs
+      } = result;
       return {
         fields: `${field.fieldId}: ${field.multipleValues ? `[${fieldType}!]` : fieldType}`,
         typeDefs
@@ -164,13 +192,18 @@ const plugin = {
       field,
       createFieldResolvers
     }) {
+      if (!field.settings.fields || field.settings.fields.length === 0) {
+        return false;
+      }
+
       const fieldType = `${graphQLType}_${(0, _upperFirst.default)(field.fieldId)}`;
+      const typeResolvers = createFieldResolvers({
+        graphQLType: fieldType,
+        fields: field.settings.fields
+      });
       return {
         resolver: null,
-        typeResolvers: createFieldResolvers({
-          graphQLType: fieldType,
-          fields: field.settings.fields
-        })
+        typeResolvers: typeResolvers || {}
       };
     }
 

package/content/plugins/modelManager/DefaultCmsModelManager.d.ts

@@ -1,4 +1,4 @@
-import { CmsModelManager, CmsModel, CmsContext } from "../../../types";
+import { CmsModelManager, CmsModel, CmsContext, CmsEntryListParams } from "../../../types";
 export declare class DefaultCmsModelManager implements CmsModelManager {
     private readonly _context;
     private readonly _model;
@@ -6,9 +6,8 @@ export declare class DefaultCmsModelManager implements CmsModelManager {
     create(data: any): Promise<import("../../../types").CmsEntry>;
     delete(id: string): Promise<void>;
     get(id: string): Promise<import("../../../types").CmsEntry>;
-    list(args: any): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
-    listPublished(args: any): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
-    listLatest(args: any): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
+    listPublished(params: CmsEntryListParams): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
+    listLatest(params: CmsEntryListParams): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
     getPublishedByIds(ids: string[]): Promise<import("../../../types").CmsEntry[]>;
     getLatestByIds(ids: string[]): Promise<import("../../../types").CmsEntry[]>;
     update(id: any, data: any): Promise<import("../../../types").CmsEntry>;

package/content/plugins/modelManager/DefaultCmsModelManager.js

@@ -39,16 +39,12 @@ class DefaultCmsModelManager {
     return this._context.cms.getEntryById(this._model, id);
   }
 
-  async list(args) {
-    return this._context.cms.listEntries(this._model, args);
+  async listPublished(params) {
+    return this._context.cms.listPublishedEntries(this._model, params);
   }
 
-  async listPublished(args) {
-    return this._context.cms.listPublishedEntries(this._model, args);
-  }
-
-  async listLatest(args) {
-    return this._context.cms.listLatestEntries(this._model, args);
+  async listLatest(params) {
+    return this._context.cms.listLatestEntries(this._model, params);
   }
 
   async getPublishedByIds(ids) {

package/content/plugins/schema/contentEntries.js

@@ -76,11 +76,15 @@ const plugin = context => {
           const getters = models.filter(model => modelIds.includes(model.modelId)).map(async model => {
             const latest = query === "__latest__";
             const modelManager = await context.cms.getModelManager(model.modelId);
+            const where = {};
+
+            if (!latest) {
+              where[`${model.titleFieldId}_contains`] = query;
+            }
+
             const [items] = await modelManager.listLatest({
               limit,
-              where: latest ? undefined : {
-                [`${model.titleFieldId}_contains`]: query
-              }
+              where
             });
             return items.map(entry => ({
               id: entry.id,

package/content/plugins/schema/contentModels.js

@@ -50,6 +50,14 @@ const plugin = context => {
           return new _handlerGraphql.ErrorResponse(e);
         }
       },
+      createContentModelFrom: async (_, args, context) => {
+        try {
+          const model = await context.cms.createModelFrom(args.modelId, args.data);
+          return new _handlerGraphql.Response(model);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      },
       updateContentModel: async (_, args, context) => {
         const {
           modelId,
@@ -120,6 +128,14 @@ const plugin = context => {
                 description: String
             }
 
+            input CmsContentModelCreateFromInput {
+                name: String!
+                modelId: String
+                group: RefInput!
+                description: String
+                locale: String
+            }
+
             input CmsContentModelUpdateInput {
                 name: String
                 group: RefInput
@@ -132,6 +148,11 @@ const plugin = context => {
             extend type Mutation {
                 createContentModel(data: CmsContentModelCreateInput!): CmsContentModelResponse
 
+                createContentModelFrom(
+                    modelId: ID!
+                    data: CmsContentModelCreateFromInput!
+                ): CmsContentModelResponse
+
                 updateContentModel(
                     modelId: ID!
                     data: CmsContentModelUpdateInput!

package/content/plugins/schema/createFieldResolvers.js

@@ -55,10 +55,16 @@ function createFieldResolversFactory({
         field,
         createFieldResolvers
       }) : null;
+      /**
+       * When fieldResolver is false it will completely skip adding fieldId into the resolvers.
+       * This is to fix the breaking of GraphQL schema.
+       */
 
-      if (typeof fieldResolver === "function") {
+      if (fieldResolver === false) {
+        continue;
+      } else if (typeof fieldResolver === "function") {
         resolver = fieldResolver;
-      } else if (fieldResolver !== null) {
+      } else if (fieldResolver) {
         resolver = fieldResolver.resolver;
         Object.assign(typeResolvers, fieldResolver.typeResolvers);
       }

package/content/plugins/schema/createManageResolvers.js

@@ -54,6 +54,13 @@ const createManageResolvers = ({
   model,
   fieldTypePlugins
 }) => {
+  if (model.fields.length === 0) {
+    return {
+      Query: {},
+      Mutation: {}
+    };
+  }
+
   const typeName = (0, _createTypeName.createTypeName)(model.modelId);
   const mTypeName = (0, _createTypeName.createManageTypeName)(typeName);
   const createFieldResolvers = (0, _createFieldResolvers.createFieldResolversFactory)({
@@ -62,6 +69,18 @@ const createManageResolvers = ({
     model,
     fieldTypePlugins
   });
+  const fieldResolvers = createFieldResolvers({
+    graphQLType: mTypeName,
+    fields: model.fields,
+    isRoot: true,
+    // These are extra fields we want to apply to field resolvers of "gqlType"
+    extraResolvers: _objectSpread(_objectSpread({}, (0, _commonFieldResolvers.commonFieldResolvers)()), {}, {
+      meta(entry) {
+        return entry;
+      }
+
+    })
+  });
   return _objectSpread(_objectSpread({
     Query: {
       [`get${typeName}`]: (0, _resolveGet.resolveGet)({
@@ -106,18 +125,7 @@ const createManageResolvers = ({
         model
       })
     }
-  }, createFieldResolvers({
-    graphQLType: mTypeName,
-    fields: model.fields,
-    isRoot: true,
-    // These are extra fields we want to apply to field resolvers of "gqlType"
-    extraResolvers: _objectSpread(_objectSpread({}, (0, _commonFieldResolvers.commonFieldResolvers)()), {}, {
-      meta(entry) {
-        return entry;
-      }
-
-    })
-  })), {}, {
+  }, fieldResolvers), {}, {
     [`${mTypeName}Meta`]: {
       title(entry) {
         return (0, _getEntryTitle.getEntryTitle)(model, entry);

package/content/plugins/schema/createManageSDL.js

@@ -47,10 +47,15 @@ const createManageSDL = ({
     type: "manage",
     fieldTypePlugins
   });
+
+  if (inputFields.length === 0) {
+    return "";
+  }
+
   return (
     /* GraphQL */
     `
-        """${model.description}"""
+        """${model.description || model.modelId}"""
         ${fields.map(f => f.typeDefs).filter(Boolean).join("\n")}
 
         type ${mTypeName} {

package/content/plugins/schema/createPreviewResolvers.js

@@ -28,6 +28,12 @@ const createPreviewResolvers = ({
   model,
   fieldTypePlugins
 }) => {
+  if (model.fields.length === 0) {
+    return {
+      Query: {}
+    };
+  }
+
   const typeName = (0, _createTypeName.createTypeName)(model.modelId);
   const rTypeName = (0, _createTypeName.createReadTypeName)(typeName);
   const createFieldResolvers = (0, _createFieldResolvers.createFieldResolversFactory)({
@@ -36,6 +42,11 @@ const createPreviewResolvers = ({
     model,
     fieldTypePlugins
   });
+  const fieldResolvers = createFieldResolvers({
+    graphQLType: rTypeName,
+    fields: model.fields,
+    isRoot: true
+  });
   return _objectSpread({
     Query: {
       [`get${typeName}`]: (0, _resolveGet.resolveGet)({
@@ -45,11 +56,7 @@ const createPreviewResolvers = ({
         model
       })
     }
-  }, createFieldResolvers({
-    graphQLType: rTypeName,
-    fields: model.fields,
-    isRoot: true
-  }));
+  }, fieldResolvers);
 };
 
 exports.createPreviewResolvers = createPreviewResolvers;

package/content/plugins/schema/createReadResolvers.js

@@ -28,6 +28,12 @@ const createReadResolvers = ({
   model,
   fieldTypePlugins
 }) => {
+  if (model.fields.length === 0) {
+    return {
+      Query: {}
+    };
+  }
+
   const typeName = (0, _createTypeName.createTypeName)(model.modelId);
   const rTypeName = (0, _createTypeName.createReadTypeName)(typeName);
   const createFieldResolvers = (0, _createFieldResolvers.createFieldResolversFactory)({
@@ -36,6 +42,11 @@ const createReadResolvers = ({
     model,
     fieldTypePlugins
   });
+  const fieldResolvers = createFieldResolvers({
+    graphQLType: rTypeName,
+    fields: model.fields,
+    isRoot: true
+  });
   return _objectSpread({
     Query: {
       [`get${typeName}`]: (0, _resolveGet.resolveGet)({
@@ -45,11 +56,7 @@ const createReadResolvers = ({
         model
       })
     }
-  }, createFieldResolvers({
-    graphQLType: rTypeName,
-    fields: model.fields,
-    isRoot: true
-  }));
+  }, fieldResolvers);
 };
 
 exports.createReadResolvers = createReadResolvers;

package/content/plugins/schema/createReadSDL.js

@@ -41,6 +41,11 @@ const createReadSDL = ({
     type: "read",
     fieldTypePlugins
   });
+
+  if (fieldsRender.length === 0) {
+    return "";
+  }
+
   return `
         """${model.description || ""}"""
         ${fieldsRender.map(f => f.typeDefs).filter(Boolean).join("\n")}

package/content/plugins/schema/schemaPlugins.js

@@ -86,7 +86,7 @@ const generateSchemaPlugins = async context => {
         return;
     }
   });
-  return newPlugins;
+  return newPlugins.filter(pl => !!pl.schema.typeDefs);
 };
 
 exports.generateSchemaPlugins = generateSchemaPlugins;

package/content/plugins/utils/renderFields.js

@@ -39,7 +39,9 @@ const renderField = ({
     fieldTypePlugins
   });
 
-  if (typeof defs === "string") {
+  if (!defs) {
+    return null;
+  } else if (typeof defs === "string") {
     return {
       fields: defs
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/api-headless-cms",
-	"version": "5.19.1",
+	"version": "5.20.0",
 	"main": "index.js",
 	"keywords": [
 		"cms:base"
@@ -21,23 +21,23 @@
 		"@babel/runtime": "7.16.3",
 		"@commodo/fields": "1.1.2-beta.20",
 		"@graphql-tools/schema": "7.1.5",
-		"@webiny/api-file-manager": "5.19.1",
-		"@webiny/api-i18n": "5.19.1",
-		"@webiny/api-i18n-content": "5.19.1",
-		"@webiny/api-i18n-ddb": "5.19.1",
-		"@webiny/api-security": "5.19.1",
-		"@webiny/api-tenancy": "5.19.1",
-		"@webiny/api-upgrade": "5.19.1",
-		"@webiny/error": "5.19.1",
-		"@webiny/handler": "5.19.1",
-		"@webiny/handler-aws": "5.19.1",
-		"@webiny/handler-db": "5.19.1",
-		"@webiny/handler-graphql": "5.19.1",
-		"@webiny/handler-http": "5.19.1",
-		"@webiny/plugins": "5.19.1",
-		"@webiny/pubsub": "5.19.1",
-		"@webiny/utils": "5.19.1",
-		"@webiny/validation": "5.19.1",
+		"@webiny/api-file-manager": "5.20.0",
+		"@webiny/api-i18n": "5.20.0",
+		"@webiny/api-i18n-content": "5.20.0",
+		"@webiny/api-i18n-ddb": "5.20.0",
+		"@webiny/api-security": "5.20.0",
+		"@webiny/api-tenancy": "5.20.0",
+		"@webiny/api-upgrade": "5.20.0",
+		"@webiny/error": "5.20.0",
+		"@webiny/handler": "5.20.0",
+		"@webiny/handler-aws": "5.20.0",
+		"@webiny/handler-db": "5.20.0",
+		"@webiny/handler-graphql": "5.20.0",
+		"@webiny/handler-http": "5.20.0",
+		"@webiny/plugins": "5.20.0",
+		"@webiny/pubsub": "5.20.0",
+		"@webiny/utils": "5.20.0",
+		"@webiny/validation": "5.20.0",
 		"boolean": "3.1.4",
 		"commodo-fields-object": "1.0.6",
 		"dataloader": "2.0.0",
@@ -54,10 +54,10 @@
 		"@babel/core": "^7.5.5",
 		"@babel/preset-env": "^7.5.5",
 		"@babel/preset-flow": "^7.0.0",
-		"@webiny/api-security-so-ddb": "^5.19.1",
-		"@webiny/api-tenancy-so-ddb": "^5.19.1",
-		"@webiny/cli": "^5.19.1",
-		"@webiny/project-utils": "^5.19.1",
+		"@webiny/api-security-so-ddb": "^5.20.0",
+		"@webiny/api-tenancy-so-ddb": "^5.20.0",
+		"@webiny/cli": "^5.20.0",
+		"@webiny/project-utils": "^5.20.0",
 		"apollo-graphql": "^0.4.1",
 		"get-yarn-workspaces": "^1.0.2",
 		"graphql": "^14.6.0",
@@ -77,5 +77,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "1424145d10add470e70fba9c44225656894e0028"
+	"gitHead": "816632961750d4ae7f3af0d32d4e8a46c3f287a6"
 }

package/plugins/context.js

@@ -17,7 +17,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 var _default = () => {
   return new _ContextPlugin.ContextPlugin(context => {
-    const locale = context.i18nContent.getLocale();
+    const locale = context.i18nContent.getCurrentLocale();
     context.cms = _objectSpread(_objectSpread({}, context.cms || {}), {}, {
       locale: locale ? locale.code : "en-US",
 

package/types.d.ts

@@ -364,7 +364,7 @@ export interface CmsModelFieldToGraphQLCreateResolver {
     }): GraphQLFieldResolver | {
         resolver: GraphQLFieldResolver;
         typeResolvers: Resolvers<CmsContext>;
-    };
+    } | false;
 }
 /**
  * @category Plugin
@@ -455,7 +455,7 @@ export interface CmsModelFieldToGraphQLPlugin extends Plugin {
             model: CmsModel;
             field: CmsModelField;
             fieldTypePlugins: CmsFieldTypePlugins;
-        }): CmsModelFieldDefinition | string;
+        }): CmsModelFieldDefinition | string | null;
         /**
          * Definition for field resolver.
          * By default it is simple return of the `instance.values[fieldId]` but if required, users can define their own.
@@ -556,7 +556,7 @@ export interface CmsModelFieldToGraphQLPlugin extends Plugin {
             model: CmsModel;
             field: CmsModelField;
             fieldTypePlugins: CmsFieldTypePlugins;
-        }) => CmsModelFieldDefinition | string;
+        }) => CmsModelFieldDefinition | string | null;
         /**
          * Definition for input GraphQL field type.
          *
@@ -905,6 +905,22 @@ export interface CmsModelCreateInput {
      * Description of the content model.
      */
     description?: string;
+    /**
+     * Group where to put the content model in.
+     */
+    group: string;
+}
+/**
+ * A GraphQL params.data parameter received when creating content model from existing model.
+ *
+ * @category GraphQL params
+ * @category CmsModel
+ */
+export interface CmsModelCreateFromInput extends CmsModelCreateInput {
+    /**
+     * Locale into which we want to clone the model into.
+     */
+    locale?: string;
 }
 /**
  * A definition for content model field received from the user.
@@ -977,6 +993,10 @@ export interface CmsModelUpdateInput {
      * A new content model name.
      */
     name?: string;
+    /**
+     * A group we want to move the model to.
+     */
+    group?: string;
     /**
      * A new description of the content model.
      */
@@ -1118,18 +1138,14 @@ export interface CmsStorageEntry extends CmsEntry {
  * @category CmsModel
  */
 export interface CmsModelManager {
-    /**
-     * List entries in this content model.
-     */
-    list: (params?: CmsEntryListParams) => Promise<[CmsEntry[], CmsEntryMeta]>;
     /**
      * List only published entries in the content model.
      */
-    listPublished: (params?: CmsEntryListParams) => Promise<[CmsEntry[], CmsEntryMeta]>;
+    listPublished: (params: CmsEntryListParams) => Promise<[CmsEntry[], CmsEntryMeta]>;
     /**
      * List latest entries in the content model. Used for administration.
      */
-    listLatest: (params?: CmsEntryListParams) => Promise<[CmsEntry[], CmsEntryMeta]>;
+    listLatest: (params: CmsEntryListParams) => Promise<[CmsEntry[], CmsEntryMeta]>;
     /**
      * Get a list of published entries by the ID list.
      */
@@ -1156,20 +1172,30 @@ export interface CmsModelManager {
     delete: (id: string) => Promise<void>;
 }
 export interface BeforeModelCreateTopicParams {
-    input: Partial<CmsModel>;
+    input: CmsModelCreateInput;
     model: CmsModel;
 }
 export interface AfterModelCreateTopicParams {
-    input: Partial<CmsModel>;
+    input: CmsModelCreateInput;
+    model: CmsModel;
+}
+export interface BeforeModelCreateFromTopicParams {
+    input: CmsModelCreateFromInput;
+    original: CmsModel;
+    model: CmsModel;
+}
+export interface AfterModelCreateFromTopicParams {
+    input: CmsModelCreateFromInput;
+    original: CmsModel;
     model: CmsModel;
 }
 export interface BeforeModelUpdateTopicParams {
-    input: Partial<CmsModel>;
+    input: CmsModelUpdateInput;
     original: CmsModel;
     model: CmsModel;
 }
 export interface AfterModelUpdateTopicParams {
-    input: Partial<CmsModel>;
+    input: CmsModelUpdateInput;
     original: CmsModel;
     model: CmsModel;
 }
@@ -1211,12 +1237,12 @@ export interface CmsModelContext {
      * Create a content model.
      */
     createModel: (data: CmsModelCreateInput) => Promise<CmsModel>;
+    /**
+     * Create a content model from the given model - clone.
+     */
+    createModelFrom: (modelId: string, data: CmsModelCreateFromInput) => Promise<CmsModel>;
     /**
      * Update content model without data validation. Used internally.
-     *
-     * @param model - existing content model
-     * @param data - data to be updated
-     *
      * @hidden
      */
     updateModelDirect: (params: CmsModelUpdateDirectParams) => Promise<CmsModel>;
@@ -1244,6 +1270,8 @@ export interface CmsModelContext {
      */
     onBeforeModelCreate: Topic<BeforeModelCreateTopicParams>;
     onAfterModelCreate: Topic<AfterModelCreateTopicParams>;
+    onBeforeModelCreateFrom: Topic<BeforeModelCreateFromTopicParams>;
+    onAfterModelCreateFrom: Topic<AfterModelCreateFromTopicParams>;
     onBeforeModelUpdate: Topic<BeforeModelUpdateTopicParams>;
     onAfterModelUpdate: Topic<AfterModelUpdateTopicParams>;
     onBeforeModelDelete: Topic<BeforeModelDeleteTopicParams>;
@@ -1496,7 +1524,7 @@ export interface CmsEntryContext {
     /**
      * List entries for a model. Internal method used by get, listLatest and listPublished.
      */
-    listEntries: (model: CmsModel, params?: CmsEntryListParams) => Promise<[CmsEntry[], CmsEntryMeta]>;
+    listEntries: (model: CmsModel, params: CmsEntryListParams) => Promise<[CmsEntry[], CmsEntryMeta]>;
     /**
      * Lists latest entries. Used for manage API.
      */

package/types.js

@@ -191,6 +191,13 @@ exports.CONTENT_ENTRY_STATUS = void 0;
  * @category CmsModel
  */
 
+/**
+ * A GraphQL params.data parameter received when creating content model from existing model.
+ *
+ * @category GraphQL params
+ * @category CmsModel
+ */
+
 /**
  * A definition for content model field received from the user.
  *