@strapi/plugin-graphql 4.15.5-alpha.6 → 4.16.0

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

@@ -1,25 +0,0 @@
-'use strict';
-
-const { sanitize, validate } = require('@strapi/utils');
-
-module.exports = ({ strapi }) => ({
-  buildComponentResolver({ contentTypeUID, attributeName }) {
-    const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
-
-    return async (parent, args = {}, ctx) => {
-      const contentType = strapi.getModel(contentTypeUID);
-
-      const { component: componentName } = contentType.attributes[attributeName];
-      const component = strapi.getModel(componentName);
-
-      const transformedArgs = transformArgs(args, { contentType: component, usePagination: true });
-      await validate.contentAPI.query(transformedArgs, component, {
-        auth: ctx?.state?.auth,
-      });
-      const sanitizedQuery = await sanitize.contentAPI.query(transformedArgs, component, {
-        auth: ctx?.state?.auth,
-      });
-      return strapi.entityService.load(contentTypeUID, parent, attributeName, sanitizedQuery);
-    };
-  },
-});

package/server/services/builders/resolvers/dynamic-zone.js

@@ -1,9 +0,0 @@
-'use strict';
-
-module.exports = ({ strapi }) => ({
-  buildDynamicZoneResolver({ contentTypeUID, attributeName }) {
-    return async (parent) => {
-      return strapi.entityService.load(contentTypeUID, parent, attributeName);
-    };
-  },
-});

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

@@ -1,18 +0,0 @@
-'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

@@ -1,38 +0,0 @@
-'use strict';
-
-const { pick } = require('lodash/fp');
-const { sanitize, validate } = require('@strapi/utils');
-
-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, ctx) {
-        const { id, ...rest } = args;
-        await validate.contentAPI.query(rest, contentType, {
-          auth: ctx?.state?.auth,
-        });
-        const sanitizedQuery = await sanitize.contentAPI.query(rest, contentType, {
-          auth: ctx?.state?.auth,
-        });
-        return strapi.entityService.delete(uid, id, sanitizedQuery);
-      },
-    };
-  },
-});

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

@@ -1,34 +0,0 @@
-'use strict';
-
-const { omit } = require('lodash/fp');
-const { sanitize, validate } = require('@strapi/utils');
-
-module.exports = ({ strapi }) => ({
-  buildQueriesResolvers({ contentType }) {
-    const { uid } = contentType;
-
-    return {
-      async find(parent, args, ctx) {
-        await validate.contentAPI.query(args, contentType, {
-          auth: ctx?.state?.auth,
-        });
-        const sanitizedQuery = await sanitize.contentAPI.query(args, contentType, {
-          auth: ctx?.state?.auth,
-        });
-
-        return strapi.entityService.findMany(uid, sanitizedQuery);
-      },
-
-      async findOne(parent, args, ctx) {
-        await validate.contentAPI.query(args, contentType, {
-          auth: ctx?.state?.auth,
-        });
-        const sanitizedQuery = await sanitize.contentAPI.query(args, contentType, {
-          auth: ctx?.state?.auth,
-        });
-
-        return strapi.entityService.findOne(uid, args.id, omit('id', sanitizedQuery));
-      },
-    };
-  },
-});

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

@@ -1,40 +0,0 @@
-'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

@@ -1,32 +0,0 @@
-'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

@@ -1,363 +0,0 @@
-'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 }) => {
-    let localBuilder = builder;
-
-    const { naming } = getGraphQLService('utils');
-    const { getContentTypeArgs } = getGraphQLService('builders').utils;
-    const { buildComponentResolver } = getGraphQLService('builders').get('content-api');
-
-    const type = naming.getComponentNameFromAttribute(attribute);
-
-    if (attribute.repeatable) {
-      localBuilder = localBuilder.list;
-    }
-
-    const targetComponent = strapi.getModel(attribute.component);
-
-    const resolve = buildComponentResolver({
-      contentTypeUID: contentType.uid,
-      attributeName,
-      strapi,
-    });
-
-    const args = getContentTypeArgs(targetComponent, { multiple: !!attribute.repeatable });
-
-    localBuilder.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');
-
-    const { 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');
-
-    const { 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 };
-
-              // Enums
-              if (isEnumeration(attribute)) {
-                addEnumAttribute(options);
-              }
-
-              // Scalars
-              else if (isStrapiScalar(attribute)) {
-                addScalarAttribute(options);
-              }
-
-              // Components
-              else if (isComponent(attribute)) {
-                addComponentAttribute(options);
-              }
-
-              // Dynamic Zones
-              else if (isDynamicZone(attribute)) {
-                addDynamicZoneAttribute(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

@@ -1,134 +0,0 @@
-'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
-      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
-      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;
-    },
-  };
-};