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

package/admin/src/translations/zh-Hans.json

@@ -0,0 +1,4 @@
+{
+  "plugin.description.long": "为默认API方法添加GraphQL端点",
+  "plugin.description.short": "为默认API方法添加GraphQL端点"
+}

package/package.json

@@ -1,38 +1,40 @@
 {
   "name": "@strapi/plugin-graphql",
-  "version": "4.0.0-next.2",
+  "version": "4.0.0-next.20",
   "description": "Adds GraphQL endpoint with default API methods.",
   "strapi": {
+    "displayName": "GraphQL",
     "name": "graphql",
     "icon": "plug",
-    "description": "graphql.plugin.description"
+    "description": "graphql.plugin.description",
+    "kind": "plugin"
   },
   "scripts": {
     "test": "echo \"no tests yet\""
   },
   "dependencies": {
-    "@apollo/federation": "^0.20.7",
-    "@graphql-tools/utils": "7.2.4",
-    "@strapi/utils": "4.0.0-next.2",
-    "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.0-next.20",
+    "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": "12.0.0",
     "koa-compose": "^4.1.0",
     "lodash": "4.17.21",
+    "nexus": "1.1.0",
     "pluralize": "^8.0.0"
   },
   "devDependencies": {
     "cross-env": "^7.0.3",
-    "koa": "^2.13.1",
-    "rimraf": "3.0.2"
+    "koa": "^2.13.1"
   },
   "author": {
     "name": "A Strapi developer",
@@ -51,5 +53,5 @@
     "npm": ">=6.0.0"
   },
   "license": "SEE LICENSE IN LICENSE",
-  "gitHead": "50849e68c7d3632eb5899c6346e33d71a211a3bd"
+  "gitHead": "9807c78cb7ab6373b7abb46da5ecc4980a9ea56c"
 }

package/server/bootstrap.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const { isEmpty, mergeWith, isArray } = require('lodash/fp');
+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 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 defaultServerConfig = {
+    // Schema
+    schema,
+
+    // Initialize loaders for this request.
+    context: ({ ctx }) => ({
+      state: ctx.state,
+      koaContext: ctx,
+    }),
+
+    // Validation
+    validationRules: [depthLimit(config('depthLimit'))],
+
+    // Misc
+    cors: false,
+    uploads: false,
+    bodyParserConfig: true,
+
+    plugins: [
+      process.env.NODE_ENV === 'production'
+        ? ApolloServerPluginLandingPageDisabled()
+        : ApolloServerPluginLandingPageGraphQLPlayground(),
+    ],
+  };
+
+  const serverConfig = merge(defaultServerConfig, config('apolloServer', {}));
+
+  // Create a new Apollo server
+  const server = new ApolloServer(serverConfig);
+
+  // Link the Apollo server & the Strapi app
+  const path = config('endpoint', '/graphql');
+
+  // 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);
+  }
+
+  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/services/builders/dynamic-zones.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const { Kind, valueFromASTUntyped, GraphQLError } = require('graphql');
+const { omit } = require('lodash/fp');
+const { unionType, scalarType } = require('nexus');
+
+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 Error(
+          `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 GraphQLError(
+          `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,84 @@
+'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 } = 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()
+        );
+
+        // 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 });
+  },
+});

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

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

package/server/services/builders/filters/operators/ends-with.js

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+const EQ_FIELD_NAME = 'eq';
+
+module.exports = ({ strapi }) => ({
+  fieldName: EQ_FIELD_NAME,
+
+  strapiOperator: '$eq',
+
+  add(t, type) {
+    const { GRAPHQL_SCALARS } = strapi.plugin('graphql').service('constants');
+
+    if (!GRAPHQL_SCALARS.includes(type)) {
+      throw new Error(`Can't use "${EQ_FIELD_NAME}" operator. "${type}" is not a valid scalar`);
+    }
+
+    t.field(EQ_FIELD_NAME, { type });
+  },
+});

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+'use strict';
+
+const { mapValues } = require('lodash/fp');
+
+const operators = {
+  and: require('./and'),
+  or: require('./or'),
+  not: require('./not'),
+
+  eq: require('./eq'),
+  ne: require('./ne'),
+
+  startsWith: require('./starts-with'),
+  endsWith: require('./ends-with'),
+
+  contains: require('./contains'),
+  notContains: require('./not-contains'),
+
+  containsi: require('./containsi'),
+  notContainsi: require('./not-containsi'),
+
+  gt: require('./gt'),
+  gte: require('./gte'),
+
+  lt: require('./lt'),
+  lte: require('./lte'),
+
+  null: require('./null'),
+  notNull: require('./not-null'),
+
+  in: require('./in'),
+  notIn: require('./not-in'),
+
+  between: require('./between'),
+};
+
+// Instantiate every operator with the Strapi instance
+module.exports = context => mapValues(opCtor => opCtor(context), operators);

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

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

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

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

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

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