@strapi/plugin-graphql 4.0.0-next.8 → 4.0.2

package/server/services/builders/mutations/collection-type.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const { extendType, nonNull } = require('nexus');
+const { sanitize } = require('@strapi/utils');
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { transformArgs } = getService('builders').utils;
+  const { toEntityResponse } = getService('format').returnTypes;
+
+  const {
+    getCreateMutationTypeName,
+    getUpdateMutationTypeName,
+    getDeleteMutationTypeName,
+    getEntityResponseName,
+    getContentTypeInputName,
+  } = naming;
+
+  const addCreateMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const createMutationName = getCreateMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(createMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Create payload
+        data: nonNull(getContentTypeInputName(contentType)),
+      },
+
+      async resolve(parent, args, context) {
+        const { auth } = context.state;
+        const transformedArgs = transformArgs(args, { contentType });
+
+        // Sanitize input data
+        const sanitizedInputData = await sanitize.contentAPI.input(
+          transformedArgs.data,
+          contentType,
+          { auth }
+        );
+
+        Object.assign(transformedArgs, { data: sanitizedInputData });
+
+        const { create } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const value = await create(parent, transformedArgs);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  const addUpdateMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const updateMutationName = getUpdateMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    // todo[v4]: Don't allow to filter using every unique attributes for now
+    // Only authorize filtering using unique scalar fields for updateOne queries
+    // const uniqueAttributes = getUniqueAttributesFiltersMap(attributes);
+
+    t.field(updateMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Query args
+        id: nonNull('ID'),
+        // todo[v4]: Don't allow to filter using every unique attributes for now
+        // ...uniqueAttributes,
+
+        // Update payload
+        data: nonNull(getContentTypeInputName(contentType)),
+      },
+
+      async resolve(parent, args, context) {
+        const { auth } = context.state;
+        const transformedArgs = transformArgs(args, { contentType });
+
+        // Sanitize input data
+        const sanitizedInputData = await sanitize.contentAPI.input(
+          transformedArgs.data,
+          contentType,
+          { auth }
+        );
+
+        Object.assign(transformedArgs, { data: sanitizedInputData });
+
+        const { update } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const value = await update(parent, transformedArgs);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  const addDeleteMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const deleteMutationName = getDeleteMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    // todo[v4]: Don't allow to filter using every unique attributes for now
+    // Only authorize filtering using unique scalar fields for updateOne queries
+    // const uniqueAttributes = getUniqueAttributesFiltersMap(attributes);
+
+    t.field(deleteMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Query args
+        id: nonNull('ID'),
+        // todo[v4]: Don't allow to filter using every unique attributes for now
+        // ...uniqueAttributes,
+      },
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        const { delete: deleteResolver } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const value = await deleteResolver(parent, args);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  return {
+    buildCollectionTypeMutations(contentType) {
+      const createMutationName = `Mutation.${getCreateMutationTypeName(contentType)}`;
+      const updateMutationName = `Mutation.${getUpdateMutationTypeName(contentType)}`;
+      const deleteMutationName = `Mutation.${getDeleteMutationTypeName(contentType)}`;
+
+      const extension = getService('extension');
+
+      const registerAuthConfig = (action, auth) => {
+        return extension.use({ resolversConfig: { [action]: { auth } } });
+      };
+
+      const isActionEnabled = action => {
+        return extension.shadowCRUD(contentType.uid).isActionEnabled(action);
+      };
+
+      const isCreateEnabled = isActionEnabled('create');
+      const isUpdateEnabled = isActionEnabled('update');
+      const isDeleteEnabled = isActionEnabled('delete');
+
+      if (isCreateEnabled) {
+        registerAuthConfig(createMutationName, { scope: [`${contentType.uid}.create`] });
+      }
+
+      if (isUpdateEnabled) {
+        registerAuthConfig(updateMutationName, { scope: [`${contentType.uid}.update`] });
+      }
+
+      if (isDeleteEnabled) {
+        registerAuthConfig(deleteMutationName, { scope: [`${contentType.uid}.delete`] });
+      }
+
+      return extendType({
+        type: 'Mutation',
+
+        definition(t) {
+          if (isCreateEnabled) {
+            addCreateMutation(t, contentType);
+          }
+
+          if (isUpdateEnabled) {
+            addUpdateMutation(t, contentType);
+          }
+
+          if (isDeleteEnabled) {
+            addDeleteMutation(t, contentType);
+          }
+        },
+      });
+    },
+  };
+};

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

@@ -0,0 +1,9 @@
+'use strict';
+
+const createCollectionTypeMutationsBuilder = require('./collection-type');
+const createSingleTypeMutationsBuilder = require('./single-type');
+
+module.exports = context => ({
+  ...createCollectionTypeMutationsBuilder(context),
+  ...createSingleTypeMutationsBuilder(context),
+});

package/server/services/builders/mutations/single-type.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const { extendType, nonNull } = require('nexus');
+const { omit, isNil } = require('lodash/fp');
+
+const utils = require('@strapi/utils');
+
+const { sanitize } = utils;
+const { NotFoundError } = utils.errors;
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { transformArgs } = getService('builders').utils;
+  const { toEntityResponse } = getService('format').returnTypes;
+
+  const {
+    getUpdateMutationTypeName,
+    getEntityResponseName,
+    getContentTypeInputName,
+    getDeleteMutationTypeName,
+  } = naming;
+
+  const addUpdateMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const updateMutationName = getUpdateMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(updateMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Update payload
+        data: nonNull(getContentTypeInputName(contentType)),
+      },
+
+      async resolve(parent, args, context) {
+        const { auth } = context.state;
+        const transformedArgs = transformArgs(args, { contentType });
+
+        // Sanitize input data
+        const sanitizedInputData = await sanitize.contentAPI.input(
+          transformedArgs.data,
+          contentType,
+          { auth }
+        );
+
+        Object.assign(transformedArgs, { data: sanitizedInputData });
+
+        const { create, update } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const findParams = omit(['data', 'files'], transformedArgs);
+        const entity = await strapi.entityService.findMany(uid, { params: findParams });
+
+        // Create or update
+        const value = isNil(entity)
+          ? create(parent, transformedArgs)
+          : update(uid, { id: entity.id, data: transformedArgs.data });
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  const addDeleteMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const deleteMutationName = getDeleteMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(deleteMutationName, {
+      type: responseTypeName,
+
+      args: {},
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        const { delete: deleteResolver } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const entity = await strapi.entityService.findMany(uid, { params: transformedArgs });
+
+        if (!entity) {
+          throw new NotFoundError('Entity not found');
+        }
+
+        const value = await deleteResolver(parent, { id: entity.id, params: transformedArgs });
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  return {
+    buildSingleTypeMutations(contentType) {
+      const updateMutationName = `Mutation.${getUpdateMutationTypeName(contentType)}`;
+      const deleteMutationName = `Mutation.${getDeleteMutationTypeName(contentType)}`;
+
+      const extension = getService('extension');
+
+      const registerAuthConfig = (action, auth) => {
+        return extension.use({ resolversConfig: { [action]: { auth } } });
+      };
+
+      const isActionEnabled = action => {
+        return extension.shadowCRUD(contentType.uid).isActionEnabled(action);
+      };
+
+      const isUpdateEnabled = isActionEnabled('update');
+      const isDeleteEnabled = isActionEnabled('delete');
+
+      if (isUpdateEnabled) {
+        registerAuthConfig(updateMutationName, { scope: [`${contentType.uid}.update`] });
+      }
+
+      if (isDeleteEnabled) {
+        registerAuthConfig(deleteMutationName, { scope: [`${contentType.uid}.delete`] });
+      }
+
+      return extendType({
+        type: 'Mutation',
+
+        definition(t) {
+          if (isUpdateEnabled) {
+            addUpdateMutation(t, contentType);
+          }
+
+          if (isDeleteEnabled) {
+            addDeleteMutation(t, contentType);
+          }
+        },
+      });
+    },
+  };
+};

package/server/services/builders/queries/collection-type.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const { extendType } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { transformArgs, getContentTypeArgs } = getService('builders').utils;
+  const { toEntityResponse, toEntityResponseCollection } = getService('format').returnTypes;
+
+  const {
+    getFindOneQueryName,
+    getEntityResponseName,
+    getFindQueryName,
+    getEntityResponseCollectionName,
+  } = naming;
+
+  const buildCollectionTypeQueries = contentType => {
+    const findOneQueryName = `Query.${getFindOneQueryName(contentType)}`;
+    const findQueryName = `Query.${getFindQueryName(contentType)}`;
+
+    const extension = getService('extension');
+
+    const registerAuthConfig = (action, auth) => {
+      return extension.use({ resolversConfig: { [action]: { auth } } });
+    };
+
+    const isActionEnabled = action => {
+      return extension.shadowCRUD(contentType.uid).isActionEnabled(action);
+    };
+
+    const isFindOneEnabled = isActionEnabled('findOne');
+    const isFindEnabled = isActionEnabled('find');
+
+    if (isFindOneEnabled) {
+      registerAuthConfig(findOneQueryName, { scope: [`${contentType.uid}.findOne`] });
+    }
+
+    if (isFindEnabled) {
+      registerAuthConfig(findQueryName, { scope: [`${contentType.uid}.find`] });
+    }
+
+    return extendType({
+      type: 'Query',
+
+      definition(t) {
+        if (isFindOneEnabled) {
+          addFindOneQuery(t, contentType);
+        }
+
+        if (isFindEnabled) {
+          addFindQuery(t, contentType);
+        }
+      },
+    });
+  };
+
+  /**
+   * Register a "find one" query field to the nexus type definition
+   * @param {OutputDefinitionBlock<Query>} t
+   * @param contentType
+   */
+  const addFindOneQuery = (t, contentType) => {
+    const { uid } = contentType;
+
+    const findOneQueryName = getFindOneQueryName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(findOneQueryName, {
+      type: responseTypeName,
+
+      args: getContentTypeArgs(contentType, { multiple: false }),
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        const { findOne } = getService('builders')
+          .get('content-api')
+          .buildQueriesResolvers({ contentType });
+
+        const value = findOne(parent, transformedArgs);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  /**
+   * Register a "find" query field to the nexus type definition
+   * @param {OutputDefinitionBlock<Query>} t
+   * @param contentType
+   */
+  const addFindQuery = (t, contentType) => {
+    const { uid } = contentType;
+
+    const findQueryName = getFindQueryName(contentType);
+    const responseCollectionTypeName = getEntityResponseCollectionName(contentType);
+
+    t.field(findQueryName, {
+      type: responseCollectionTypeName,
+
+      args: getContentTypeArgs(contentType),
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType, usePagination: true });
+
+        const { find } = getService('builders')
+          .get('content-api')
+          .buildQueriesResolvers({ contentType });
+
+        const nodes = await find(parent, transformedArgs);
+
+        return toEntityResponseCollection(nodes, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  return { buildCollectionTypeQueries };
+};

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

@@ -0,0 +1,9 @@
+'use strict';
+
+const createCollectionTypeQueriesBuilder = require('./collection-type');
+const createSingleTypeQueriesBuilder = require('./single-type');
+
+module.exports = context => ({
+  ...createCollectionTypeQueriesBuilder(context),
+  ...createSingleTypeQueriesBuilder(context),
+});

package/server/services/builders/queries/single-type.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const { extendType } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { transformArgs, getContentTypeArgs } = getService('builders').utils;
+  const { toEntityResponse } = getService('format').returnTypes;
+
+  const { getFindOneQueryName, getEntityResponseName } = naming;
+
+  const buildSingleTypeQueries = contentType => {
+    const findQueryName = `Query.${getFindOneQueryName(contentType)}`;
+
+    const extension = getService('extension');
+
+    const registerAuthConfig = (action, auth) => {
+      return extension.use({ resolversConfig: { [action]: { auth } } });
+    };
+
+    const isActionEnabled = action => {
+      return extension.shadowCRUD(contentType.uid).isActionEnabled(action);
+    };
+
+    const isFindEnabled = isActionEnabled('find');
+
+    if (isFindEnabled) {
+      registerAuthConfig(findQueryName, { scope: [`${contentType.uid}.find`] });
+    }
+
+    return extendType({
+      type: 'Query',
+
+      definition(t) {
+        if (isFindEnabled) {
+          addFindQuery(t, contentType);
+        }
+      },
+    });
+  };
+
+  const addFindQuery = (t, contentType) => {
+    const { uid } = contentType;
+
+    const findQueryName = getFindOneQueryName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(findQueryName, {
+      type: responseTypeName,
+
+      args: getContentTypeArgs(contentType),
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        const queriesResolvers = getService('builders')
+          .get('content-api')
+          .buildQueriesResolvers({ contentType });
+
+        const value = queriesResolvers.find(parent, transformedArgs);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  return { buildSingleTypeQueries };
+};

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

@@ -0,0 +1,35 @@
+'use strict';
+
+const { objectType, nonNull } = require('nexus');
+const { defaultTo, prop, pipe } = require('lodash/fp');
+
+module.exports = ({ strapi }) => {
+  const { naming } = strapi.plugin('graphql').service('utils');
+
+  return {
+    /**
+     * Build a type definition for a content API relation's 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}
+     */
+    buildRelationResponseCollectionDefinition(contentType) {
+      const name = naming.getRelationResponseCollectionName(contentType);
+      const entityName = naming.getEntityName(contentType);
+
+      return objectType({
+        name,
+
+        definition(t) {
+          t.nonNull.list.field('data', {
+            type: nonNull(entityName),
+
+            resolve: pipe(
+              prop('nodes'),
+              defaultTo([])
+            ),
+          });
+        },
+      });
+    },
+  };
+};

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

@@ -0,0 +1,85 @@
+'use strict';
+
+const { get } = require('lodash/fp');
+
+const utils = require('@strapi/utils');
+
+const { sanitize, pipeAsync } = utils;
+const { ApplicationError } = utils.errors;
+
+module.exports = ({ strapi }) => {
+  const { service: getGraphQLService } = strapi.plugin('graphql');
+
+  const { isMorphRelation, isMedia } = getGraphQLService('utils').attributes;
+  const { transformArgs } = getGraphQLService('builders').utils;
+  const { toEntityResponse, toEntityResponseCollection } = getGraphQLService('format').returnTypes;
+
+  return {
+    buildAssociationResolver({ contentTypeUID, attributeName }) {
+      const contentType = strapi.getModel(contentTypeUID);
+      const attribute = contentType.attributes[attributeName];
+
+      if (!attribute) {
+        throw new ApplicationError(
+          `Failed to build an association resolver for ${contentTypeUID}::${attributeName}`
+        );
+      }
+
+      const isMediaAttribute = isMedia(attribute);
+      const isMorphAttribute = isMorphRelation(attribute);
+
+      const targetUID = isMediaAttribute ? 'plugins::upload.file' : attribute.target;
+      const isToMany = isMediaAttribute ? attribute.multiple : attribute.relation.endsWith('Many');
+
+      const targetContentType = strapi.getModel(targetUID);
+
+      return async (parent, args = {}, context) => {
+        const { auth } = context.state;
+
+        const transformedArgs = transformArgs(args, {
+          contentType: targetContentType,
+          usePagination: true,
+        });
+
+        const data = await strapi.entityService.load(
+          contentTypeUID,
+          parent,
+          attributeName,
+          transformedArgs
+        );
+
+        const info = {
+          args: transformedArgs,
+          resourceUID: targetUID,
+        };
+
+        // If this a polymorphic association, it sanitizes & returns the raw data
+        // Note: The value needs to be wrapped in a fake object that represents its parent
+        // so that the sanitize util can work properly.
+        if (isMorphAttribute) {
+          // Helpers used for the data cleanup
+          const wrapData = dataToWrap => ({ [attributeName]: dataToWrap });
+          const sanitizeData = dataToSanitize => {
+            return sanitize.contentAPI.output(dataToSanitize, contentType, { auth });
+          };
+          const unwrapData = get(attributeName);
+
+          // Sanitizer definition
+          const sanitizeMorphAttribute = pipeAsync(wrapData, sanitizeData, unwrapData);
+
+          return sanitizeMorphAttribute(data);
+        }
+
+        // If this is a to-many relation, it returns an object that
+        // matches what the entity-response-collection's resolvers expect
+        else if (isToMany) {
+          return toEntityResponseCollection(data, info);
+        }
+
+        // Else, it returns an object that matches
+        // what the entity-response's resolvers expect
+        return toEntityResponse(data, info);
+      };
+    },
+  };
+};

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

@@ -0,0 +1,18 @@
+'use strict';
+
+module.exports = ({ strapi }) => ({
+  buildComponentResolver({ contentTypeUID, attributeName }) {
+    const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+
+    return async (parent, args = {}) => {
+      const contentType = strapi.getModel(contentTypeUID);
+
+      const { component: componentName } = contentType.attributes[attributeName];
+      const component = strapi.getModel(componentName);
+
+      const transformedArgs = transformArgs(args, { contentType: component, usePagination: true });
+
+      return strapi.entityService.load(contentTypeUID, parent, attributeName, transformedArgs);
+    };
+  },
+});

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

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