@strapi/plugin-graphql 4.0.0-next.6 → 4.0.0

package/server/services/builders/resolvers/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const associationResolvers = require('./association');
+const queriesResolvers = require('./query');
+const mutationsResolvers = require('./mutation');
+const componentResolvers = require('./component');
+const dynamicZoneResolvers = require('./dynamic-zone');
+
+module.exports = context => ({
+  // Generics
+  ...associationResolvers(context),
+
+  // Builders
+  ...mutationsResolvers(context),
+  ...queriesResolvers(context),
+  ...componentResolvers(context),
+  ...dynamicZoneResolvers(context),
+});

package/server/services/builders/resolvers/mutation.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { pick } = require('lodash/fp');
+
+const pickCreateArgs = pick(['params', 'data', 'files']);
+
+module.exports = ({ strapi }) => ({
+  buildMutationsResolvers({ contentType }) {
+    const { uid } = contentType;
+
+    return {
+      async create(parent, args) {
+        // todo[v4]: Might be interesting to generate dynamic yup schema to validate payloads with more complex checks (on top of graphql validation)
+        const params = pickCreateArgs(args);
+
+        // todo[v4]: Sanitize args to only keep params / data / files (or do it in the base resolver)
+        return strapi.entityService.create(uid, params);
+      },
+
+      async update(parent, args) {
+        const { id, data } = args;
+
+        return strapi.entityService.update(uid, id, { data });
+      },
+
+      async delete(parent, args) {
+        const { id, ...rest } = args;
+
+        return strapi.entityService.delete(uid, id, rest);
+      },
+    };
+  },
+});

package/server/services/builders/resolvers/query.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { omit } = require('lodash/fp');
+
+module.exports = ({ strapi }) => ({
+  buildQueriesResolvers({ contentType }) {
+    const { uid } = contentType;
+
+    return {
+      async find(parent, args) {
+        return strapi.entityService.findMany(uid, args);
+      },
+
+      async findOne(parent, args) {
+        return strapi.entityService.findOne(uid, args.id, omit('id', args));
+      },
+    };
+  },
+});

package/server/services/builders/response-collection.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { objectType, nonNull } = require('nexus');
+const { defaultTo, prop, pipe } = require('lodash/fp');
+
+module.exports = ({ strapi }) => {
+  const { naming } = strapi.plugin('graphql').service('utils');
+  const { RESPONSE_COLLECTION_META_TYPE_NAME } = strapi.plugin('graphql').service('constants');
+
+  return {
+    /**
+     * Build a type definition for a content API collection response for a given content type
+     * @param {object} contentType The content type which will be used to build its content API response definition
+     * @return {NexusObjectTypeDef}
+     */
+    buildResponseCollectionDefinition(contentType) {
+      const name = naming.getEntityResponseCollectionName(contentType);
+      const entityName = naming.getEntityName(contentType);
+
+      return objectType({
+        name,
+
+        definition(t) {
+          t.nonNull.list.field('data', {
+            type: nonNull(entityName),
+
+            resolve: pipe(
+              prop('nodes'),
+              defaultTo([])
+            ),
+          });
+
+          t.nonNull.field('meta', {
+            type: RESPONSE_COLLECTION_META_TYPE_NAME,
+
+            // Pass down the args stored in the source object
+            resolve: prop('info'),
+          });
+        },
+      });
+    },
+  };
+};

package/server/services/builders/response.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { objectType } = require('nexus');
+const { prop } = require('lodash/fp');
+
+module.exports = ({ strapi }) => {
+  const { naming } = strapi.plugin('graphql').service('utils');
+
+  return {
+    /**
+     * Build a type definition for a content API response for a given content type
+     * @param {object} contentType The content type which will be used to build its content API response definition
+     * @return {NexusObjectTypeDef}
+     */
+    buildResponseDefinition(contentType) {
+      const name = naming.getEntityResponseName(contentType);
+      const entityName = naming.getEntityName(contentType);
+
+      return objectType({
+        name,
+
+        definition(t) {
+          t.field('data', {
+            type: entityName,
+
+            resolve: prop('value'),
+          });
+        },
+      });
+    },
+  };
+};

package/server/services/builders/type.js

@@ -0,0 +1,364 @@
+'use strict';
+
+const { isArray, isString, isUndefined, constant } = require('lodash/fp');
+const { objectType } = require('nexus');
+
+const { contentTypes } = require('@strapi/utils');
+
+/**
+ * @typedef TypeBuildersOptions
+ *
+ * @property {ObjectDefinitionBlock} builder
+ * @property {string} attributeName
+ * @property {object} attribute
+ * @property {object} contentType
+ * @property {object} context
+ * @property {object} context.strapi
+ * @property {object} context.registry
+ */
+module.exports = context => {
+  const { strapi } = context;
+
+  const getGraphQLService = strapi.plugin('graphql').service;
+
+  const extension = getGraphQLService('extension');
+
+  /**
+   * Add a scalar attribute to the type definition
+   *
+   * The attribute is added based on a simple association between a Strapi
+   * type and a GraphQL type (the map is defined in `strapiTypeToGraphQLScalar`)
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addScalarAttribute = ({ builder, attributeName, attribute }) => {
+    const { mappers } = getGraphQLService('utils');
+
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+    builder.field(attributeName, { type: gqlType });
+  };
+
+  /**
+   * Add a component attribute to the type definition
+   *
+   * The attribute is added by fetching the component's type
+   * name and using it as the attribute's type
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addComponentAttribute = ({ builder, attributeName, contentType, attribute }) => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildComponentResolver } = getGraphQLService('builders').get('content-api');
+
+    const type = naming.getComponentNameFromAttribute(attribute);
+
+    if (attribute.repeatable) {
+      builder = builder.list;
+    }
+
+    const targetComponent = strapi.getModel(attribute.component);
+
+    const resolve = buildComponentResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    const args = getContentTypeArgs(targetComponent, { multiple: !!attribute.repeatable });
+
+    builder.field(attributeName, { type, resolve, args });
+  };
+
+  /**
+   * Add a dynamic zone attribute to the type definition
+   *
+   * The attribute is added by fetching the dynamic zone's
+   * type name and using it as the attribute's type
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addDynamicZoneAttribute = ({ builder, attributeName, contentType }) => {
+    const { naming } = getGraphQLService('utils');
+    const { ERROR_CODES } = getGraphQLService('constants');
+    const { buildDynamicZoneResolver } = getGraphQLService('builders').get('content-api');
+
+    const { components } = contentType.attributes[attributeName];
+
+    const isEmpty = components.length === 0;
+    const type = naming.getDynamicZoneName(contentType, attributeName);
+
+    const resolve = isEmpty
+      ? // If the dynamic zone don't have any component, then return an error payload
+        constant({
+          code: ERROR_CODES.emptyDynamicZone,
+          message: `This dynamic zone don't have any component attached to it`,
+        })
+      : //  Else, return a classic dynamic-zone resolver
+        buildDynamicZoneResolver({
+          contentTypeUID: contentType.uid,
+          attributeName,
+        });
+
+    builder.list.field(attributeName, { type, resolve });
+  };
+
+  /**
+   * Add an enum attribute to the type definition
+   *
+   * The attribute is added by fetching the enum's type
+   * name and using it as the attribute's type
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addEnumAttribute = ({ builder, attributeName, contentType }) => {
+    const { naming } = getGraphQLService('utils');
+
+    const type = naming.getEnumName(contentType, attributeName);
+
+    builder.field(attributeName, { type });
+  };
+
+  /**
+   * Add a media attribute to the type definition
+   * @param {TypeBuildersOptions} options
+   */
+  const addMediaAttribute = options => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    const extension = getGraphQLService('extension');
+
+    let { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+    const fileUID = 'plugin::upload.file';
+
+    if (extension.shadowCRUD(fileUID).isDisabled()) {
+      return;
+    }
+
+    const fileContentType = strapi.contentTypes[fileUID];
+
+    const resolve = buildAssociationResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    const args = attribute.multiple ? getContentTypeArgs(fileContentType) : undefined;
+    const type = attribute.multiple
+      ? naming.getRelationResponseCollectionName(fileContentType)
+      : naming.getEntityResponseName(fileContentType);
+
+    builder.field(attributeName, { type, resolve, args });
+  };
+
+  /**
+   * Add a polymorphic relational attribute to the type definition
+   * @param {TypeBuildersOptions} options
+   */
+  const addPolymorphicRelationalAttribute = options => {
+    const { GENERIC_MORPH_TYPENAME } = getGraphQLService('constants');
+    const { naming } = getGraphQLService('utils');
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+
+    let { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+
+    const { target } = attribute;
+    const isToManyRelation = attribute.relation.endsWith('Many');
+
+    if (isToManyRelation) {
+      builder = builder.list;
+    }
+    // todo[v4]: How to handle polymorphic relation w/ entity response collection types?
+    //  -> Currently return raw polymorphic entities
+
+    const resolve = buildAssociationResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    // If there is no specific target specified, then use the GenericMorph type
+    if (isUndefined(target)) {
+      builder.field(attributeName, {
+        type: GENERIC_MORPH_TYPENAME,
+        resolve,
+      });
+    }
+
+    // If the target is an array of string, resolve the associated morph type and use it
+    else if (isArray(target) && target.every(isString)) {
+      const type = naming.getMorphRelationTypeName(contentType, attributeName);
+
+      builder.field(attributeName, { type, resolve });
+    }
+  };
+
+  /**
+   * Add a regular relational attribute to the type definition
+   * @param {TypeBuildersOptions} options
+   */
+  const addRegularRelationalAttribute = options => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    const extension = getGraphQLService('extension');
+
+    let { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+
+    if (extension.shadowCRUD(attribute.target).isDisabled()) {
+      return;
+    }
+
+    const isToManyRelation = attribute.relation.endsWith('Many');
+
+    const resolve = buildAssociationResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    const targetContentType = strapi.getModel(attribute.target);
+
+    const type = isToManyRelation
+      ? naming.getRelationResponseCollectionName(targetContentType)
+      : naming.getEntityResponseName(targetContentType);
+
+    const args = isToManyRelation ? getContentTypeArgs(targetContentType) : undefined;
+
+    const resolverPath = `${naming.getTypeName(contentType)}.${attributeName}`;
+    const resolverScope = `${targetContentType.uid}.find`;
+
+    extension.use({ resolversConfig: { [resolverPath]: { auth: { scope: [resolverScope] } } } });
+
+    builder.field(attributeName, { type, resolve, args });
+  };
+
+  const isNotPrivate = contentType => attributeName => {
+    return !contentTypes.isPrivateAttribute(contentType, attributeName);
+  };
+
+  const isNotDisabled = contentType => attributeName => {
+    return extension
+      .shadowCRUD(contentType.uid)
+      .field(attributeName)
+      .hasOutputEnabled();
+  };
+
+  return {
+    /**
+     * Create a type definition for a given content type
+     * @param contentType - The content type used to created the definition
+     * @return {NexusObjectTypeDef}
+     */
+    buildTypeDefinition(contentType) {
+      const utils = getGraphQLService('utils');
+
+      const { getComponentName, getTypeName } = utils.naming;
+      const {
+        isStrapiScalar,
+        isComponent,
+        isDynamicZone,
+        isEnumeration,
+        isMedia,
+        isMorphRelation,
+        isRelation,
+      } = utils.attributes;
+
+      const { attributes, modelType } = contentType;
+
+      const attributesKey = Object.keys(attributes);
+
+      const name = (modelType === 'component' ? getComponentName : getTypeName).call(
+        null,
+        contentType
+      );
+
+      return objectType({
+        name,
+
+        definition(t) {
+          if (modelType === 'component' && isNotDisabled(contentType)('id')) {
+            t.nonNull.id('id');
+          }
+
+          /** Attributes
+           *
+           * Attributes can be of 7 different kind:
+           * - Scalar
+           * - Component
+           * - Dynamic Zone
+           * - Enum
+           * - Media
+           * - Polymorphic Relations
+           * - Regular Relations
+           *
+           * Here, we iterate over each non-private attribute
+           * and add it to the type definition based on its type
+           */
+          attributesKey
+            // Ignore private attributes
+            .filter(isNotPrivate(contentType))
+            // Ignore disabled fields (from extension service)
+            .filter(isNotDisabled(contentType))
+            // Add each attribute to the type definition
+            .forEach(attributeName => {
+              const attribute = attributes[attributeName];
+
+              // We create a copy of the builder (t) to apply custom
+              // rules only on the current attribute (eg: nonNull, list, ...)
+              let builder = t;
+
+              if (attribute.required) {
+                builder = builder.nonNull;
+              }
+
+              /**
+               * @type {TypeBuildersOptions}
+               */
+              const options = { builder, attributeName, attribute, contentType, context };
+
+              // Scalars
+              if (isStrapiScalar(attribute)) {
+                addScalarAttribute(options);
+              }
+
+              // Components
+              else if (isComponent(attribute)) {
+                addComponentAttribute(options);
+              }
+
+              // Dynamic Zones
+              else if (isDynamicZone(attribute)) {
+                addDynamicZoneAttribute(options);
+              }
+
+              // Enums
+              else if (isEnumeration(attribute)) {
+                addEnumAttribute(options);
+              }
+
+              // Media
+              else if (isMedia(attribute)) {
+                addMediaAttribute(options);
+              }
+
+              // Polymorphic Relations
+              else if (isMorphRelation(attribute)) {
+                addPolymorphicRelationalAttribute(options);
+              }
+
+              // Regular Relations
+              else if (isRelation(attribute)) {
+                addRegularRelationalAttribute(options);
+              }
+            });
+        },
+      });
+    },
+  };
+};

package/server/services/builders/utils.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const { entries, mapValues, omit } = require('lodash/fp');
+const {
+  pagination: { withDefaultPagination },
+  contentTypes: { hasDraftAndPublish },
+} = require('@strapi/utils');
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  return {
+    /**
+     * Get every args for a given content type
+     * @param {object} contentType
+     * @param {object} options
+     * @param {boolean} options.multiple
+     * @return {object}
+     */
+    getContentTypeArgs(contentType, { multiple = true } = {}) {
+      const { naming } = getService('utils');
+      const { args } = getService('internals');
+
+      const { kind, modelType } = contentType;
+
+      // Components
+      if (modelType === 'component') {
+        if (!multiple) return {};
+
+        return {
+          filters: naming.getFiltersInputTypeName(contentType),
+          pagination: args.PaginationArg,
+          sort: args.SortArg,
+        };
+      }
+
+      // Collection Types
+      else if (kind === 'collectionType') {
+        if (!multiple) {
+          return { id: 'ID' };
+        }
+
+        const params = {
+          filters: naming.getFiltersInputTypeName(contentType),
+          pagination: args.PaginationArg,
+          sort: args.SortArg,
+        };
+
+        if (hasDraftAndPublish(contentType)) {
+          Object.assign(params, { publicationState: args.PublicationStateArg });
+        }
+
+        return params;
+      }
+
+      // Single Types
+      else if (kind === 'singleType') {
+        const params = {};
+
+        if (hasDraftAndPublish(contentType)) {
+          Object.assign(params, { publicationState: args.PublicationStateArg });
+        }
+
+        return params;
+      }
+    },
+
+    /**
+     * Filter an object entries and keep only those whose value is a unique scalar attribute
+     * @param {object} attributes
+     * @return {Object<string, object>}
+     */
+    getUniqueScalarAttributes(attributes) {
+      const { isStrapiScalar } = getService('utils').attributes;
+
+      const uniqueAttributes = entries(attributes).filter(
+        ([, attribute]) => isStrapiScalar(attribute) && attribute.unique
+      );
+
+      return Object.fromEntries(uniqueAttributes);
+    },
+
+    /**
+     * Map each value from an attribute to a FiltersInput type name
+     * @param {object} attributes - The attributes object to transform
+     * @return {Object<string, string>}
+     */
+    scalarAttributesToFiltersMap: mapValues(attribute => {
+      const { mappers, naming } = getService('utils');
+
+      const gqlScalar = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+      return naming.getScalarFilterInputTypeName(gqlScalar);
+    }),
+
+    /**
+     * Apply basic transform to GQL args
+     */
+    transformArgs(args, { contentType, usePagination = false } = {}) {
+      const { mappers } = getService('utils');
+      const { config } = strapi.plugin('graphql');
+      const { pagination = {}, filters = {} } = args;
+
+      // Init
+      const newArgs = omit(['pagination', 'filters'], args);
+
+      // Pagination
+      if (usePagination) {
+        const defaultLimit = config('defaultLimit');
+        const maxLimit = config('maxLimit');
+
+        Object.assign(
+          newArgs,
+          withDefaultPagination(pagination, {
+            maxLimit,
+            defaults: {
+              offset: { limit: defaultLimit },
+              page: { pageSize: defaultLimit },
+            },
+          })
+        );
+      }
+
+      // Filters
+      if (args.filters) {
+        Object.assign(newArgs, {
+          filters: mappers.graphQLFiltersToStrapiQuery(filters, contentType),
+        });
+      }
+
+      return newArgs;
+    },
+  };
+};