@strapi/plugin-graphql 4.0.0-next.2 → 4.0.0-next.20

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,64 @@
+'use strict';
+
+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 Error(
+          `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 = {}) => {
+        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 returns the raw data
+        if (isMorphAttribute) {
+          return 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,14 @@
+'use strict';
+
+module.exports = ({ strapi }) => ({
+  buildComponentResolver({ contentTypeUID, attributeName }) {
+    const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+
+    return async (parent, args = {}) => {
+      const contentType = strapi.contentTypes[contentTypeUID];
+      const transformedArgs = transformArgs(args, { contentType, 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);
+    };
+  },
+});

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'),
+          });
+        },
+      });
+    },
+  };
+};