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

package/README.md

@@ -3,4 +3,4 @@
 This plugin will add GraphQL functionality to your app.
 By default it will provide you with most of the CRUD methods exposed in the Strapi REST API.
 
-To learn more about GraphQL in Strapi [visit documentation](https://strapi.io/documentation/developer-docs/latest/development/plugins/graphql.html)
+To learn more about GraphQL in Strapi [visit documentation](https://docs.strapi.io/developer-docs/latest/plugins/graphql.html)

package/admin/src/index.js

@@ -1,22 +1,14 @@
 import { prefixPluginTranslations } from '@strapi/helper-plugin';
 import pluginPkg from '../../package.json';
 import pluginId from './pluginId';
-import pluginLogo from './assets/images/logo.svg';
 
-const pluginDescription = pluginPkg.strapi.description || pluginPkg.description;
-const icon = pluginPkg.strapi.icon;
 const name = pluginPkg.strapi.name;
 
 export default {
   register(app) {
     app.registerPlugin({
-      description: pluginDescription,
-      icon,
       id: pluginId,
-      isReady: true,
-      isRequired: pluginPkg.strapi.required || false,
       name,
-      pluginLogo,
     });
   },
   bootstrap() {},

package/package.json

@@ -1,57 +1,65 @@
 {
   "name": "@strapi/plugin-graphql",
-  "version": "4.0.0-next.8",
+  "version": "4.0.2",
   "description": "Adds GraphQL endpoint with default API methods.",
-  "strapi": {
-    "displayName": "GraphQL",
-    "name": "graphql",
-    "icon": "plug",
-    "description": "graphql.plugin.description",
-    "kind": "plugin"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/strapi/strapi.git",
+    "directory": "packages/plugins/graphql"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Strapi Solutions SAS",
+    "email": "hi@strapi.io",
+    "url": "https://strapi.io"
   },
+  "maintainers": [
+    {
+      "name": "Strapi Solutions SAS",
+      "email": "hi@strapi.io",
+      "url": "https://strapi.io"
+    }
+  ],
   "scripts": {
-    "test": "echo \"no tests yet\""
+    "test:front": "cross-env IS_EE=true jest --config ./jest.config.front.js",
+    "test:front:watch": "cross-env IS_EE=true jest --config ./jest.config.front.js --watchAll",
+    "test:front:ce": "cross-env IS_EE=false jest --config ./jest.config.front.js",
+    "test:front:watch:ce": "cross-env IS_EE=false jest --config ./jest.config.front.js --watchAll"
   },
   "dependencies": {
-    "@apollo/federation": "^0.20.7",
-    "@graphql-tools/utils": "7.2.4",
-    "@strapi/utils": "4.0.0-next.8",
-    "apollo-server-koa": "2.24.0",
-    "dataloader": "^1.4.0",
-    "glob": "^7.1.6",
-    "graphql": "15.5.0",
+    "@apollo/federation": "^0.28.0",
+    "@graphql-tools/schema": "8.1.2",
+    "@graphql-tools/utils": "^8.0.2",
+    "@strapi/utils": "4.0.2",
+    "apollo-server-core": "3.1.2",
+    "apollo-server-koa": "3.1.2",
+    "glob": "^7.1.7",
+    "graphql": "15.5.1",
     "graphql-depth-limit": "^1.1.0",
     "graphql-iso-date": "^3.6.1",
     "graphql-playground-middleware-koa": "^1.6.21",
-    "graphql-tools": "4.0.8",
-    "graphql-type-json": "0.3.2",
+    "graphql-type-json": "^0.3.2",
     "graphql-type-long": "^0.1.1",
-    "graphql-upload": "11.0.0",
+    "graphql-upload": "^13.0.0",
     "koa-compose": "^4.1.0",
     "lodash": "4.17.21",
-    "pluralize": "^8.0.0"
+    "nexus": "1.1.0",
+    "pluralize": "^8.0.0",
+    "subscriptions-transport-ws": "0.9.19"
   },
   "devDependencies": {
     "cross-env": "^7.0.3",
-    "koa": "^2.13.1",
-    "rimraf": "3.0.2"
+    "koa": "^2.13.1"
   },
-  "author": {
-    "name": "A Strapi developer",
-    "email": "",
-    "url": ""
-  },
-  "maintainers": [
-    {
-      "name": "A Strapi developer",
-      "email": "",
-      "url": ""
-    }
-  ],
   "engines": {
     "node": ">=12.x.x <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "license": "SEE LICENSE IN LICENSE",
-  "gitHead": "e3452f6662a45a4ba96e96861e076e313b297666"
+  "strapi": {
+    "displayName": "GraphQL",
+    "name": "graphql",
+    "description": "Adds GraphQL endpoint with default API methods.",
+    "kind": "plugin"
+  },
+  "gitHead": "fd656a47698e0a33aae42abd4330410c8cba1d08"
 }

package/server/bootstrap.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const { isEmpty, mergeWith, isArray } = require('lodash/fp');
+const { execute, subscribe } = require('graphql');
+const { SubscriptionServer } = require('subscriptions-transport-ws');
+const { ApolloServer } = require('apollo-server-koa');
+const {
+  ApolloServerPluginLandingPageDisabled,
+  ApolloServerPluginLandingPageGraphQLPlayground,
+} = require('apollo-server-core');
+const depthLimit = require('graphql-depth-limit');
+const { graphqlUploadKoa } = require('graphql-upload');
+const formatGraphqlError = require('./format-graphql-error');
+
+const merge = mergeWith((a, b) => {
+  if (isArray(a) && isArray(b)) {
+    return a.concat(b);
+  }
+});
+
+module.exports = async ({ strapi }) => {
+  // Generate the GraphQL schema for the content API
+  const schema = strapi
+    .plugin('graphql')
+    .service('content-api')
+    .buildSchema();
+
+  if (isEmpty(schema)) {
+    strapi.log.warn('The GraphQL schema has not been generated because it is empty');
+
+    return;
+  }
+
+  const { config } = strapi.plugin('graphql');
+
+  const path = config('endpoint');
+
+  const defaultServerConfig = {
+    // Schema
+    schema,
+
+    // Initialize loaders for this request.
+    context: ({ ctx }) => ({
+      state: ctx.state,
+      koaContext: ctx,
+    }),
+
+    // Validation
+    validationRules: [depthLimit(config('depthLimit'))],
+
+    // Errors
+    formatError: formatGraphqlError,
+
+    // Misc
+    cors: false,
+    uploads: false,
+    bodyParserConfig: true,
+
+    plugins: [
+      process.env.NODE_ENV === 'production'
+        ? ApolloServerPluginLandingPageDisabled()
+        : ApolloServerPluginLandingPageGraphQLPlayground(),
+    ],
+  };
+
+  const serverConfig = merge(defaultServerConfig, config('apolloServer'));
+
+  // Handle subscriptions
+  if (config('subscriptions')) {
+    const subscriptionServer = SubscriptionServer.create(
+      { schema, execute, subscribe },
+      { server: strapi.server.httpServer, path }
+    );
+
+    serverConfig.plugins.push({
+      async serverWillStart() {
+        return {
+          async drainServer() {
+            subscriptionServer.close();
+          },
+        };
+      },
+    });
+  }
+
+  // Create a new Apollo server
+  const server = new ApolloServer(serverConfig);
+
+  // Register the upload middleware
+  useUploadMiddleware(strapi, path);
+
+  try {
+    // Since Apollo-Server v3, server.start() must be called before using server.applyMiddleware()
+    await server.start();
+  } catch (e) {
+    strapi.log.error('Failed to start the Apollo server', e.message);
+  }
+
+  // Link the Apollo server & the Strapi app
+  strapi.server.routes([
+    {
+      method: 'ALL',
+      path,
+      handler: [
+        (ctx, next) => {
+          ctx.state.route = {
+            info: {
+              // Indicate it's a content API route
+              type: 'content-api',
+            },
+          };
+
+          return strapi.auth.authenticate(ctx, next);
+        },
+
+        // Apollo Server
+        server.getMiddleware({ path }),
+      ],
+      config: {
+        auth: false,
+      },
+    },
+  ]);
+
+  // Register destroy behavior
+  // We're doing it here instead of exposing a destroy method to the strapi-server.js
+  // file since we need to have access to the ApolloServer instance
+  strapi.plugin('graphql').destroy = async () => {
+    await server.stop();
+  };
+};
+
+/**
+ * Register the upload middleware powered by graphql-upload in Strapi
+ * @param {object} strapi
+ * @param {string} path
+ */
+const useUploadMiddleware = (strapi, path) => {
+  const uploadMiddleware = graphqlUploadKoa();
+
+  strapi.server.app.use((ctx, next) => {
+    if (ctx.path === path) {
+      return uploadMiddleware(ctx, next);
+    }
+
+    return next();
+  });
+};

package/server/config/default-config.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = {
+  shadowCRUD: true,
+
+  endpoint: '/graphql',
+
+  subscriptions: false,
+
+  maxLimit: -1,
+
+  apolloServer: {},
+};

package/server/config/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const defaultConfig = require('./default-config');
+
+module.exports = {
+  default: defaultConfig,
+};

package/server/format-graphql-error.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { toUpper, snakeCase, pick, isEmpty } = require('lodash/fp');
+const {
+  HttpError,
+  ForbiddenError,
+  UnauthorizedError,
+  ApplicationError,
+  ValidationError,
+} = require('@strapi/utils').errors;
+const {
+  ApolloError,
+  UserInputError: ApolloUserInputError,
+  ForbiddenError: ApolloForbiddenError,
+} = require('apollo-server-koa');
+const { GraphQLError } = require('graphql');
+
+const formatToCode = name => `STRAPI_${toUpper(snakeCase(name))}`;
+const formatErrorToExtension = error => ({ error: pick(['name', 'message', 'details'])(error) });
+
+const formatGraphqlError = error => {
+  const { originalError } = error;
+
+  if (isEmpty(originalError)) {
+    return error;
+  }
+
+  if (originalError instanceof ForbiddenError || originalError instanceof UnauthorizedError) {
+    return new ApolloForbiddenError(originalError.message, formatErrorToExtension(originalError));
+  }
+
+  if (originalError instanceof ValidationError) {
+    return new ApolloUserInputError(originalError.message, formatErrorToExtension(originalError));
+  }
+
+  if (originalError instanceof ApplicationError || originalError instanceof HttpError) {
+    const name = formatToCode(originalError.name);
+    return new ApolloError(originalError.message, name, formatErrorToExtension(originalError));
+  }
+
+  if (originalError instanceof ApolloError || originalError instanceof GraphQLError) {
+    return error;
+  }
+
+  // Internal server error
+  strapi.log.error(originalError);
+  return ApolloError('Internal Server Error', 'INTERNAL_SERVER_ERROR');
+};
+
+module.exports = formatGraphqlError;

package/server/services/builders/dynamic-zones.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { Kind, valueFromASTUntyped } = require('graphql');
+const { omit } = require('lodash/fp');
+const { unionType, scalarType } = require('nexus');
+const { ApplicationError } = require('@strapi/utils');
+
+module.exports = ({ strapi }) => {
+  const buildTypeDefinition = (name, components) => {
+    const { ERROR_TYPE_NAME } = strapi.plugin('graphql').service('constants');
+    const isEmpty = components.length === 0;
+
+    const componentsTypeNames = components.map(componentUID => {
+      const component = strapi.components[componentUID];
+
+      if (!component) {
+        throw new ApplicationError(
+          `Trying to create a dynamic zone type with an unknown component: "${componentUID}"`
+        );
+      }
+
+      return component.globalId;
+    });
+
+    return unionType({
+      name,
+
+      resolveType(obj) {
+        if (isEmpty) {
+          return ERROR_TYPE_NAME;
+        }
+
+        return strapi.components[obj.__component].globalId;
+      },
+
+      definition(t) {
+        t.members(...componentsTypeNames, ERROR_TYPE_NAME);
+      },
+    });
+  };
+
+  const buildInputDefinition = (name, components) => {
+    const parseData = value => {
+      const component = Object.values(strapi.components).find(
+        component => component.globalId === value.__typename
+      );
+
+      if (!component) {
+        throw new ApplicationError(
+          `Component not found. expected one of: ${components
+            .map(uid => strapi.components[uid].globalId)
+            .join(', ')}`
+        );
+      }
+
+      return {
+        __component: component.uid,
+        ...omit(['__typename'], value),
+      };
+    };
+
+    return scalarType({
+      name,
+
+      serialize: value => value,
+
+      parseValue: value => parseData(value),
+
+      parseLiteral(ast, variables) {
+        if (ast.kind !== Kind.OBJECT) {
+          return undefined;
+        }
+
+        const value = valueFromASTUntyped(ast, variables);
+        return parseData(value);
+      },
+    });
+  };
+
+  return {
+    /**
+     * Build a Nexus dynamic zone type from a Strapi dz attribute
+     * @param {object} definition - The definition of the dynamic zone
+     * @param {string} name - the name of the dynamic zone
+     * @param {string} inputName - the name of the dynamic zone's input
+     * @return {[NexusUnionTypeDef, NexusScalarTypeDef]}
+     */
+    buildDynamicZoneDefinition(definition, name, inputName) {
+      const { components } = definition;
+
+      const typeDefinition = buildTypeDefinition(name, components);
+      const inputDefinition = buildInputDefinition(inputName, components);
+
+      return [typeDefinition, inputDefinition];
+    },
+  };
+};

package/server/services/builders/entity-meta.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function buildEntityMetaDefinition(/*contentType*/) {}
+
+module.exports = () => ({
+  buildEntityMetaDefinition,
+});

package/server/services/builders/entity.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { objectType } = require('nexus');
+const { prop, identity, isEmpty } = require('lodash/fp');
+
+module.exports = ({ strapi }) => {
+  const { naming } = strapi.plugin('graphql').service('utils');
+
+  return {
+    /**
+     * Build a higher level type for a content type which contains the attributes, the ID and the metadata
+     * @param {object} contentType The content type which will be used to build its entity type
+     * @return {NexusObjectTypeDef}
+     */
+    buildEntityDefinition(contentType) {
+      const { attributes } = contentType;
+
+      const name = naming.getEntityName(contentType);
+      const typeName = naming.getTypeName(contentType);
+
+      return objectType({
+        name,
+
+        definition(t) {
+          // Keep the ID attribute at the top level
+          t.id('id', { resolve: prop('id') });
+
+          if (!isEmpty(attributes)) {
+            // Keep the fetched object into a dedicated `attributes` field
+            // TODO: [v4] precise why we keep the ID
+            t.field('attributes', {
+              type: typeName,
+              resolve: identity,
+            });
+          }
+
+          // todo[v4]: add the meta field to the entity when there will be data in it (can't add an empty type for now)
+          // t.field('meta', { type: utils.getEntityMetaName(contentType) });
+        },
+      });
+    },
+  };
+};

package/server/services/builders/enums.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { enumType } = require('nexus');
+const { set } = require('lodash/fp');
+
+/**
+ * Build a Nexus enum type from a Strapi enum attribute
+ * @param {object} definition - The definition of the enum
+ * @param {string[]} definition.enum - The params of the enum
+ * @param {string} name - The name of the enum
+ * @return {NexusEnumTypeDef}
+ */
+const buildEnumTypeDefinition = (definition, name) => {
+  return enumType({
+    name,
+    // In Strapi V3, the key of an enum is also its value
+    // todo[V4]: allow passing an object of key/value instead of an array
+    members: definition.enum.reduce((acc, value) => set(value, value, acc), {}),
+  });
+};
+
+module.exports = () => ({
+  buildEnumTypeDefinition,
+});

package/server/services/builders/filters/content-type.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { inputObjectType } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const rootLevelOperators = () => {
+    const { operators } = strapi.plugin('graphql').service('builders').filters;
+
+    return [operators.and, operators.or, operators.not];
+  };
+
+  const buildContentTypeFilters = contentType => {
+    const utils = strapi.plugin('graphql').service('utils');
+    const extension = strapi.plugin('graphql').service('extension');
+
+    const { getFiltersInputTypeName, getScalarFilterInputTypeName } = utils.naming;
+    const { isStrapiScalar, isRelation } = utils.attributes;
+
+    const { attributes } = contentType;
+
+    const filtersTypeName = getFiltersInputTypeName(contentType);
+
+    return inputObjectType({
+      name: filtersTypeName,
+
+      definition(t) {
+        const validAttributes = Object.entries(attributes).filter(([attributeName]) =>
+          extension
+            .shadowCRUD(contentType.uid)
+            .field(attributeName)
+            .hasFiltersEnabeld()
+        );
+
+        const isIDFilterEnabled = extension
+          .shadowCRUD(contentType.uid)
+          .field('id')
+          .hasFiltersEnabeld();
+        // Add an ID filter to the collection types
+        if (contentType.kind === 'collectionType' && isIDFilterEnabled) {
+          t.field('id', { type: getScalarFilterInputTypeName('ID') });
+        }
+
+        // Add every defined attribute
+        for (const [attributeName, attribute] of validAttributes) {
+          // Handle scalars
+          if (isStrapiScalar(attribute)) {
+            addScalarAttribute(t, attributeName, attribute);
+          }
+
+          // Handle relations
+          else if (isRelation(attribute)) {
+            addRelationalAttribute(t, attributeName, attribute);
+          }
+        }
+
+        // Conditional clauses
+        for (const operator of rootLevelOperators()) {
+          operator.add(t, filtersTypeName);
+        }
+      },
+    });
+  };
+
+  const addScalarAttribute = (builder, attributeName, attribute) => {
+    const { naming, mappers } = strapi.plugin('graphql').service('utils');
+
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+    builder.field(attributeName, { type: naming.getScalarFilterInputTypeName(gqlType) });
+  };
+
+  const addRelationalAttribute = (builder, attributeName, attribute) => {
+    const utils = strapi.plugin('graphql').service('utils');
+    const extension = strapi.plugin('graphql').service('extension');
+    const { getFiltersInputTypeName } = utils.naming;
+    const { isMorphRelation } = utils.attributes;
+
+    const model = strapi.getModel(attribute.target);
+
+    // If there is no model corresponding to the attribute configuration
+    // or if the attribute is a polymorphic relation, then ignore it
+    if (!model || isMorphRelation(attribute)) return;
+
+    // If the target model is disabled, then ignore it too
+    if (extension.shadowCRUD(model.uid).isDisabled()) return;
+
+    builder.field(attributeName, { type: getFiltersInputTypeName(model) });
+  };
+
+  return {
+    buildContentTypeFilters,
+  };
+};

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

@@ -0,0 +1,7 @@
+'use strict';
+
+const contentType = require('./content-type');
+
+module.exports = context => ({
+  ...contentType(context),
+});

package/server/services/builders/filters/operators/and.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { list } = require('nexus');
+
+const AND_FIELD_NAME = 'and';
+
+module.exports = () => ({
+  fieldName: AND_FIELD_NAME,
+
+  strapiOperator: '$and',
+
+  add(t, type) {
+    t.field(AND_FIELD_NAME, { type: list(type) });
+  },
+});

package/server/services/builders/filters/operators/between.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { list } = require('nexus');
+
+const BETWEEN_FIELD_NAME = 'between';
+
+module.exports = () => ({
+  fieldName: BETWEEN_FIELD_NAME,
+
+  strapiOperator: '$between',
+
+  add(t, type) {
+    t.field(BETWEEN_FIELD_NAME, { type: list(type) });
+  },
+});

package/server/services/builders/filters/operators/contains.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const CONTAINS_FIELD_NAME = 'contains';
+
+module.exports = () => ({
+  fieldName: CONTAINS_FIELD_NAME,
+
+  strapiOperator: '$contains',
+
+  add(t, type) {
+    t.field(CONTAINS_FIELD_NAME, { type });
+  },
+});