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

package/content/plugins/schema/contentModels.js

@@ -0,0 +1,225 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _GraphQLSchemaPlugin = require("@webiny/handler-graphql/plugins/GraphQLSchemaPlugin");
+
+var _CmsModelPlugin = require("../CmsModelPlugin");
+
+const plugin = context => {
+  const resolvers = {
+    Query: {
+      getContentModel: async (_, args, context) => {
+        try {
+          const model = await context.cms.getModel(args.modelId);
+          return new _handlerGraphql.Response(model);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      },
+      listContentModels: async (_, __, context) => {
+        try {
+          const model = await context.cms.listModels();
+          return new _handlerGraphql.Response(model);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      }
+    },
+    CmsContentModel: {
+      plugin: async (model, _, context) => {
+        const modelPlugin = context.plugins.byType(_CmsModelPlugin.CmsModelPlugin.type).find(item => item.contentModel.modelId === model.modelId);
+        return Boolean(modelPlugin);
+      }
+    }
+  };
+  let manageSchema = "";
+
+  if (context.cms.MANAGE) {
+    resolvers.Mutation = {
+      createContentModel: async (_, args, context) => {
+        try {
+          const model = await context.cms.createModel(args.data);
+          return new _handlerGraphql.Response(model);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      },
+      updateContentModel: async (_, args, context) => {
+        const {
+          modelId,
+          data
+        } = args;
+
+        try {
+          const model = await context.cms.updateModel(modelId, data);
+          return new _handlerGraphql.Response(model);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      },
+      deleteContentModel: async (_, args, context) => {
+        const {
+          modelId
+        } = args;
+
+        try {
+          await context.cms.deleteModel(modelId);
+          return new _handlerGraphql.Response(true);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      }
+    };
+    manageSchema =
+    /* GraphQL */
+    `
+            input CmsPredefinedValueInput {
+                label: String!
+                value: String!
+            }
+
+            input CmsPredefinedValuesInput {
+                enabled: Boolean
+                values: [CmsPredefinedValueInput]
+            }
+            input CmsFieldRendererInput {
+                name: String
+            }
+
+            input CmsFieldValidationInput {
+                name: String!
+                message: String
+                settings: JSON
+            }
+
+            input CmsContentModelFieldInput {
+                id: ID!
+                label: String!
+                helpText: String
+                placeholderText: String
+                fieldId: String!
+                type: String!
+                multipleValues: Boolean
+                predefinedValues: CmsPredefinedValuesInput
+                renderer: CmsFieldRendererInput
+                validation: [CmsFieldValidationInput]
+                listValidation: [CmsFieldValidationInput]
+                settings: JSON
+            }
+
+            input CmsContentModelCreateInput {
+                name: String!
+                modelId: String
+                group: RefInput!
+                description: String
+            }
+
+            input CmsContentModelUpdateInput {
+                name: String
+                group: RefInput
+                description: String
+                layout: [[ID!]!]!
+                fields: [CmsContentModelFieldInput!]!
+                titleFieldId: String
+            }
+
+            extend type Mutation {
+                createContentModel(data: CmsContentModelCreateInput!): CmsContentModelResponse
+
+                updateContentModel(
+                    modelId: ID!
+                    data: CmsContentModelUpdateInput!
+                ): CmsContentModelResponse
+
+                deleteContentModel(modelId: ID!): CmsDeleteResponse
+            }
+        `;
+  }
+
+  return new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
+    typeDefs:
+    /* GraphQL */
+    `
+            type CmsFieldValidation {
+                name: String!
+                message: String
+                settings: JSON
+            }
+
+            type CmsFieldRenderer {
+                name: String
+            }
+
+            type CmsPredefinedValue {
+                label: String
+                value: String
+            }
+
+            type CmsPredefinedValues {
+                enabled: Boolean
+                values: [CmsPredefinedValue]
+            }
+
+            type CmsContentModelField {
+                id: ID!
+                fieldId: String!
+                label: String!
+                helpText: String
+                placeholderText: String
+                type: String!
+                multipleValues: Boolean
+                predefinedValues: CmsPredefinedValues
+                renderer: CmsFieldRenderer
+                validation: [CmsFieldValidation!]
+                listValidation: [CmsFieldValidation!]
+                settings: JSON
+            }
+
+            type CmsContentModel {
+                name: String!
+                modelId: String!
+                description: String
+                group: CmsContentModelGroup!
+                createdOn: DateTime
+                savedOn: DateTime
+                createdBy: CmsCreatedBy
+                fields: [CmsContentModelField!]!
+                lockedFields: [JSON]
+                layout: [[String!]!]!
+                titleFieldId: String
+
+                # Returns true if the content model is registered via a plugin.
+                plugin: Boolean!
+            }
+
+            type CmsContentModelResponse {
+                data: CmsContentModel
+                error: CmsError
+            }
+
+            type CmsContentModelListResponse {
+                data: [CmsContentModel]
+                meta: CmsListMeta
+                error: CmsError
+            }
+
+            extend type Query {
+                getContentModel(modelId: ID!, where: JSON, sort: String): CmsContentModelResponse
+
+                listContentModels: CmsContentModelListResponse
+            }
+
+            ${manageSchema}
+        `,
+    resolvers
+  });
+};
+
+var _default = plugin;
+exports.default = _default;

package/content/plugins/schema/createFieldResolvers.d.ts

@@ -0,0 +1,19 @@
+import { CmsModelField } from "../../../types";
+import { Resolvers } from "@webiny/handler-graphql/types";
+interface CreateFieldResolvers {
+    graphQLType: string;
+    fields: CmsModelField[];
+    isRoot: boolean;
+    extraResolvers?: Resolvers<any>;
+}
+/**
+ * We use a factory to avoid passing the parameters for recursive invocations.
+ * This way they will always be in the function scope and we can only pass "fields".
+ */
+export declare function createFieldResolversFactory({ endpointType, models, model, fieldTypePlugins }: {
+    endpointType: any;
+    models: any;
+    model: any;
+    fieldTypePlugins: any;
+}): (params: CreateFieldResolvers) => {};
+export {};

package/content/plugins/schema/createFieldResolvers.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFieldResolversFactory = createFieldResolversFactory;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _set = _interopRequireDefault(require("lodash/set"));
+
+var _entryStorage = require("../utils/entryStorage");
+
+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; }
+
+/**
+ * We use a factory to avoid passing the parameters for recursive invocations.
+ * This way they will always be in the function scope and we can only pass "fields".
+ */
+function createFieldResolversFactory({
+  endpointType,
+  models,
+  model,
+  fieldTypePlugins
+}) {
+  return function createFieldResolvers(params) {
+    const {
+      graphQLType,
+      fields,
+      isRoot = false,
+      extraResolvers = {}
+    } = params;
+
+    const fieldResolvers = _objectSpread({}, extraResolvers);
+
+    const typeResolvers = {};
+
+    for (const field of fields) {
+      if (!fieldTypePlugins[field.type]) {
+        continue;
+      }
+
+      const createResolver = (0, _get.default)(fieldTypePlugins, `${field.type}.${endpointType}.createResolver`);
+      let resolver;
+      const fieldResolver = createResolver ? createResolver({
+        graphQLType,
+        models,
+        model,
+        field,
+        createFieldResolvers
+      }) : null;
+
+      if (typeof fieldResolver === "function") {
+        resolver = fieldResolver;
+      } else if (fieldResolver !== null) {
+        resolver = fieldResolver.resolver;
+        Object.assign(typeResolvers, fieldResolver.typeResolvers);
+      }
+
+      const {
+        fieldId
+      } = field;
+
+      fieldResolvers[fieldId] = async (parent, args, context, info) => {
+        // Get transformed value (eg. data decompression)
+        const transformedValue = await (0, _entryStorage.entryFieldFromStorageTransform)({
+          context,
+          model,
+          field,
+          value: isRoot ? parent.values[fieldId] : parent[fieldId]
+        });
+        (0, _set.default)(isRoot ? parent.values : parent, fieldId, transformedValue);
+
+        if (!resolver) {
+          return isRoot ? parent.values[fieldId] : parent[fieldId];
+        }
+
+        return await resolver(isRoot ? parent.values : parent, args, context, info);
+      };
+    }
+
+    return _objectSpread({
+      [graphQLType]: fieldResolvers
+    }, typeResolvers);
+  };
+}

package/content/plugins/schema/createManageResolvers.d.ts

@@ -0,0 +1,11 @@
+import { CmsModel, CmsFieldTypePlugins, CmsContext } from "../../../types";
+interface CreateManageResolvers {
+    (params: {
+        models: CmsModel[];
+        model: CmsModel;
+        context: CmsContext;
+        fieldTypePlugins: CmsFieldTypePlugins;
+    }): any;
+}
+export declare const createManageResolvers: CreateManageResolvers;
+export {};

package/content/plugins/schema/createManageResolvers.js

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createManageResolvers = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _commonFieldResolvers = require("./resolvers/commonFieldResolvers");
+
+var _resolveGet = require("./resolvers/manage/resolveGet");
+
+var _resolveList = require("./resolvers/manage/resolveList");
+
+var _resolveGetRevisions = require("./resolvers/manage/resolveGetRevisions");
+
+var _resolveGetByIds = require("./resolvers/manage/resolveGetByIds");
+
+var _resolveCreate = require("./resolvers/manage/resolveCreate");
+
+var _resolveUpdate = require("./resolvers/manage/resolveUpdate");
+
+var _resolveRequestReview = require("./resolvers/manage/resolveRequestReview");
+
+var _resolveRequestChanges = require("./resolvers/manage/resolveRequestChanges");
+
+var _resolveDelete = require("./resolvers/manage/resolveDelete");
+
+var _resolvePublish = require("./resolvers/manage/resolvePublish");
+
+var _resolveUnpublish = require("./resolvers/manage/resolveUnpublish");
+
+var _resolveCreateFrom = require("./resolvers/manage/resolveCreateFrom");
+
+var _createFieldResolvers = require("./createFieldResolvers");
+
+var _createTypeName = require("../utils/createTypeName");
+
+var _pluralizedTypeName = require("../utils/pluralizedTypeName");
+
+var _getEntryTitle = require("../utils/getEntryTitle");
+
+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 createManageResolvers = ({
+  models,
+  model,
+  fieldTypePlugins
+}) => {
+  const typeName = (0, _createTypeName.createTypeName)(model.modelId);
+  const mTypeName = (0, _createTypeName.createManageTypeName)(typeName);
+  const createFieldResolvers = (0, _createFieldResolvers.createFieldResolversFactory)({
+    endpointType: "manage",
+    models,
+    model,
+    fieldTypePlugins
+  });
+  return _objectSpread(_objectSpread({
+    Query: {
+      [`get${typeName}`]: (0, _resolveGet.resolveGet)({
+        model
+      }),
+      [`get${typeName}Revisions`]: (0, _resolveGetRevisions.resolveGetRevisions)({
+        model
+      }),
+      [`get${(0, _pluralizedTypeName.pluralizedTypeName)(typeName)}ByIds`]: (0, _resolveGetByIds.resolveGetByIds)({
+        model
+      }),
+      [`list${(0, _pluralizedTypeName.pluralizedTypeName)(typeName)}`]: (0, _resolveList.resolveList)({
+        model
+      })
+    },
+    Mutation: {
+      [`create${typeName}`]: (0, _resolveCreate.resolveCreate)({
+        model
+      }),
+      [`update${typeName}`]: (0, _resolveUpdate.resolveUpdate)({
+        model
+      }),
+      [`delete${typeName}`]: (0, _resolveDelete.resolveDelete)({
+        model
+      }),
+      [`publish${typeName}`]: (0, _resolvePublish.resolvePublish)({
+        model
+      }),
+      [`unpublish${typeName}`]: (0, _resolveUnpublish.resolveUnpublish)({
+        model
+      }),
+      [`create${typeName}From`]: (0, _resolveCreateFrom.resolveCreateFrom)({
+        model
+      }),
+      [`request${typeName}Review`]: (0, _resolveRequestReview.resolveRequestReview)({
+        model
+      }),
+      [`request${typeName}Changes`]: (0, _resolveRequestChanges.resolveRequestChanges)({
+        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;
+      }
+
+    })
+  })), {}, {
+    [`${mTypeName}Meta`]: {
+      title(entry) {
+        return (0, _getEntryTitle.getEntryTitle)(model, entry);
+      },
+
+      status(entry) {
+        return entry.status;
+      },
+
+      async revisions(entry, _, context) {
+        const entryId = entry.id.split("#")[0];
+        const revisions = await context.cms.getEntryRevisions(model, entryId);
+        return revisions.sort((a, b) => b.version - a.version);
+      }
+
+    }
+  });
+};
+
+exports.createManageResolvers = createManageResolvers;

package/content/plugins/schema/createManageSDL.d.ts

@@ -0,0 +1,9 @@
+import { CmsFieldTypePlugins, CmsModel } from "../../../types";
+interface CreateManageSDL {
+    (params: {
+        model: CmsModel;
+        fieldTypePlugins: CmsFieldTypePlugins;
+    }): string;
+}
+export declare const createManageSDL: CreateManageSDL;
+export {};

package/content/plugins/schema/createManageSDL.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createManageSDL = void 0;
+
+var _createTypeName = require("../utils/createTypeName");
+
+var _renderListFilterFields = require("../utils/renderListFilterFields");
+
+var _renderSortEnum = require("../utils/renderSortEnum");
+
+var _renderGetFilterFields = require("../utils/renderGetFilterFields");
+
+var _renderInputFields = require("../utils/renderInputFields");
+
+var _renderFields = require("../utils/renderFields");
+
+var _pluralizedTypeName = require("../utils/pluralizedTypeName");
+
+const createManageSDL = ({
+  model,
+  fieldTypePlugins
+}) => {
+  const typeName = (0, _createTypeName.createTypeName)(model.modelId);
+  const mTypeName = (0, _createTypeName.createManageTypeName)(typeName);
+  const listFilterFieldsRender = (0, _renderListFilterFields.renderListFilterFields)({
+    model,
+    type: "manage",
+    fieldTypePlugins
+  });
+  const sortEnumRender = (0, _renderSortEnum.renderSortEnum)({
+    model,
+    fieldTypePlugins
+  });
+  const getFilterFieldsRender = (0, _renderGetFilterFields.renderGetFilterFields)({
+    model,
+    fieldTypePlugins
+  });
+  const inputFields = (0, _renderInputFields.renderInputFields)({
+    model,
+    fieldTypePlugins
+  });
+  const fields = (0, _renderFields.renderFields)({
+    model,
+    type: "manage",
+    fieldTypePlugins
+  });
+  return (
+    /* GraphQL */
+    `
+        """${model.description}"""
+        ${fields.map(f => f.typeDefs).filter(Boolean).join("\n")}
+
+        type ${mTypeName} {
+            id: ID!
+            entryId: String!
+            createdOn: DateTime!
+            savedOn: DateTime!
+            createdBy: CmsCreatedBy!
+            ownedBy: CmsOwnedBy!
+            meta: ${mTypeName}Meta
+            ${fields.map(f => f.fields).join("\n")}
+        }
+
+        type ${mTypeName}Meta {
+            modelId: String
+            version: Int
+            locked: Boolean
+            publishedOn: DateTime
+            status: String
+            """
+            CAUTION: this field is resolved by making an extra query to DB. 
+            RECOMMENDATION: Use it only with "get" queries (avoid in "list") 
+            """
+            revisions: [${mTypeName}]
+            title: String
+        }
+        
+                    
+        ${inputFields.map(f => f.typeDefs).filter(Boolean).join("\n")}
+
+        ${inputFields && `input ${mTypeName}Input {
+            ${inputFields.map(f => f.fields).join("\n")}
+        }`}
+
+        ${getFilterFieldsRender && `input ${mTypeName}GetWhereInput {
+            ${getFilterFieldsRender}
+        }`}
+
+
+        ${listFilterFieldsRender && `input ${mTypeName}ListWhereInput {
+            ${listFilterFieldsRender}
+        }`}
+
+        type ${mTypeName}Response {
+            data: ${mTypeName}
+            error: CmsError
+        }
+        
+        type ${mTypeName}ArrayResponse {
+            data: [${mTypeName}]
+            error: CmsError
+        }
+
+        type ${mTypeName}ListResponse {
+            data: [${mTypeName}]
+            meta: CmsListMeta
+            error: CmsError
+        }
+
+        ${sortEnumRender && `enum ${mTypeName}ListSorter {
+            ${sortEnumRender}
+        }`}
+
+        extend type Query {
+            get${typeName}(revision: ID!): ${mTypeName}Response
+            
+            get${typeName}Revisions(id: ID!): ${mTypeName}ArrayResponse
+            
+            get${(0, _pluralizedTypeName.pluralizedTypeName)(typeName)}ByIds(revisions: [ID!]!): ${mTypeName}ArrayResponse
+
+            list${(0, _pluralizedTypeName.pluralizedTypeName)(typeName)}(
+                where: ${mTypeName}ListWhereInput
+                sort: [${mTypeName}ListSorter]
+                limit: Int
+                after: String
+            ): ${mTypeName}ListResponse
+        }
+
+        extend type Mutation{
+            create${typeName}(data: ${mTypeName}Input!): ${mTypeName}Response
+
+            create${typeName}From(revision: ID!, data: ${mTypeName}Input): ${mTypeName}Response
+
+            update${typeName}(revision: ID!, data: ${mTypeName}Input!): ${mTypeName}Response
+
+            delete${typeName}(revision: ID!): CmsDeleteResponse
+
+            publish${typeName}(revision: ID!): ${mTypeName}Response
+
+            unpublish${typeName}(revision: ID!): ${mTypeName}Response
+            
+            request${typeName}Review(revision: ID!): ${mTypeName}Response
+            
+            request${typeName}Changes(revision: ID!): ${mTypeName}Response
+        }
+    `
+  );
+};
+
+exports.createManageSDL = createManageSDL;

package/content/plugins/schema/createPreviewResolvers.d.ts

@@ -0,0 +1,10 @@
+import { CmsModel, CmsFieldTypePlugins, CmsContext } from "../../../types";
+export interface CreateReadResolvers {
+    (params: {
+        models: CmsModel[];
+        model: CmsModel;
+        context: CmsContext;
+        fieldTypePlugins: CmsFieldTypePlugins;
+    }): any;
+}
+export declare const createPreviewResolvers: CreateReadResolvers;