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

package/server/services/content-api/wrap-resolvers.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const { get, getOr, isFunction, first, isNil } = require('lodash/fp');
+
+const { GraphQLObjectType } = require('graphql');
+const { createPoliciesMiddleware } = require('./policy');
+
+const introspectionQueries = [
+  '__Schema',
+  '__Type',
+  '__Field',
+  '__InputValue',
+  '__EnumValue',
+  '__Directive',
+];
+
+/**
+ * Wrap the schema's resolvers if they've been
+ * customized using the GraphQL extension service
+ * @param {object} options
+ * @param {GraphQLSchema} options.schema
+ * @param {object} options.strapi
+ * @param {object} options.extension
+ * @return {GraphQLSchema}
+ */
+const wrapResolvers = ({ schema, strapi, extension = {} }) => {
+  // Get all the registered resolvers configuration
+  const { resolversConfig = {} } = extension;
+
+  // Fields filters
+  const isValidFieldName = ([field]) => !field.startsWith('__');
+
+  const typeMap = schema.getTypeMap();
+
+  // Iterate over every field from every type within the
+  // schema's type map and wrap its resolve attribute if needed
+  Object.entries(typeMap).forEach(([type, definition]) => {
+    const isGraphQLObjectType = definition instanceof GraphQLObjectType;
+    const isIgnoredType = introspectionQueries.includes(type);
+
+    if (!isGraphQLObjectType || isIgnoredType) {
+      return;
+    }
+
+    const fields = definition.getFields();
+    const fieldsToProcess = Object.entries(fields).filter(isValidFieldName);
+
+    for (const [fieldName, fieldDefinition] of fieldsToProcess) {
+      const defaultResolver = get(fieldName);
+
+      const path = `${type}.${fieldName}`;
+      const resolverConfig = getOr({}, path, resolversConfig);
+
+      const { resolve: baseResolver = defaultResolver } = fieldDefinition;
+
+      // Parse & initialize the middlewares
+      const middlewares = parseMiddlewares(resolverConfig, strapi);
+
+      // Generate the policy middleware
+      const policyMiddleware = createPoliciesMiddleware(resolverConfig, { strapi });
+
+      // Add the policyMiddleware at the end of the middlewares collection
+      middlewares.push(policyMiddleware);
+
+      // Bind every middleware to the next one
+      const boundMiddlewares = middlewares.map((middleware, index, collection) => {
+        return (...args) =>
+          middleware(
+            // Make sure the last middleware in the list calls the baseResolver
+            index >= collection.length - 1 ? baseResolver : boundMiddlewares[index + 1],
+            ...args
+          );
+      });
+
+      /**
+       * GraphQL authorization flow
+       * @param {object} context
+       * @return {Promise<void>}
+       */
+      const authorize = async ({ context }) => {
+        const authConfig = get('auth', resolverConfig);
+        const authContext = get('state.auth', context);
+
+        const isMutationOrQuery = ['Mutation', 'Query'].includes(type);
+        const hasConfig = !isNil(authConfig);
+
+        const isAuthDisabled = authConfig === false;
+
+        if ((isMutationOrQuery || hasConfig) && !isAuthDisabled) {
+          try {
+            await strapi.auth.verify(authContext, authConfig);
+          } catch (error) {
+            // TODO: [v4] Throw GraphQL Error instead
+            throw new Error('Forbidden access');
+          }
+        }
+      };
+
+      /**
+       * Base resolver wrapper that handles authorization, middlewares & policies
+       * @param {object} parent
+       * @param {object} args
+       * @param {object} context
+       * @param {object} info
+       * @return {Promise<any>}
+       */
+      fieldDefinition.resolve = async (parent, args, context, info) => {
+        await authorize({ context });
+
+        // Execute middlewares (including the policy middleware which will always be included)
+        return first(boundMiddlewares).call(null, parent, args, context, info);
+      };
+    }
+  });
+
+  return schema;
+};
+
+/**
+ * Get & parse middlewares definitions from the resolver's config
+ * @param {object} resolverConfig
+ * @param {object} strapi
+ * @return {function[]}
+ */
+const parseMiddlewares = (resolverConfig, strapi) => {
+  const resolverMiddlewares = getOr([], 'middlewares', resolverConfig);
+
+  // TODO: [v4] to factorize with compose endpoints (routes)
+  return resolverMiddlewares.map(middleware => {
+    if (isFunction(middleware)) {
+      return middleware;
+    }
+
+    if (typeof middleware === 'string') {
+      return strapi.middleware(middleware);
+    }
+
+    if (typeof middleware === 'object') {
+      const { name, options = {} } = middleware;
+
+      return strapi.middleware(name)(options);
+    }
+  });
+};
+
+module.exports = { wrapResolvers };

package/server/services/extension/extension.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const nexus = require('nexus');
+const { merge } = require('lodash/fp');
+
+const createShadowCRUDManager = require('./shadow-crud-manager');
+
+/**
+ * @typedef StrapiGraphQLExtensionConfiguration
+ * @property {NexusGen[]} types - A collection of Nexus types
+ * @property {string} typeDefs - Type definitions (SDL format)
+ * @property {object} resolvers - A resolver map
+ * @property {object} resolversConfig - An object that bind a configuration to a resolver based on an absolute path (the key)
+ * @property {NexusPlugin[]} plugins - A collection of Nexus plugins
+ */
+
+/**
+ * @typedef {function({ strapi: object, nexus: object, typeRegistry: object }): StrapiGraphQLExtensionConfiguration} StrapiGraphQLExtensionConfigurationFactory
+ */
+
+const getDefaultState = () => ({
+  types: [],
+  typeDefs: [],
+  resolvers: {},
+  resolversConfig: {},
+  plugins: [],
+});
+
+const createExtension = ({ strapi } = {}) => {
+  const configs = [];
+
+  return {
+    shadowCRUD: createShadowCRUDManager({ strapi }),
+
+    /**
+     * Register a new extension configuration
+     * @param {StrapiGraphQLExtensionConfiguration | StrapiGraphQLExtensionConfigurationFactory} configuration
+     * @return {this}
+     */
+    use(configuration) {
+      configs.push(configuration);
+
+      return this;
+    },
+
+    /**
+     * Convert the registered configuration into a single extension object & return it
+     * @param {object} options
+     * @param {object} options.typeRegistry
+     * @return {object}
+     */
+    generate({ typeRegistry }) {
+      const resolveConfig = config => {
+        return typeof config === 'function' ? config({ strapi, nexus, typeRegistry }) : config;
+      };
+
+      // Evaluate & merge every registered configuration object, then return the result
+      return configs.reduce((acc, configuration) => {
+        const { types, typeDefs, resolvers, resolversConfig, plugins } = resolveConfig(
+          configuration
+        );
+
+        // Register type definitions
+        if (typeof typeDefs === 'string') {
+          acc.typeDefs.push(typeDefs);
+        }
+
+        // Register nexus types
+        if (Array.isArray(types)) {
+          acc.types.push(...types);
+        }
+
+        // Register nexus plugins
+        if (Array.isArray(plugins)) {
+          acc.plugins.push(...plugins);
+        }
+
+        // Register resolvers
+        if (typeof resolvers === 'object') {
+          acc.resolvers = merge(acc.resolvers, resolvers);
+        }
+
+        // Register resolvers configuration
+        if (typeof resolversConfig === 'object') {
+          // TODO: smarter merge for auth, middlewares & policies
+          acc.resolversConfig = merge(resolversConfig, acc.resolversConfig);
+        }
+
+        return acc;
+      }, getDefaultState());
+    },
+  };
+};
+
+module.exports = createExtension;

package/server/services/extension/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const createExtension = require('./extension');
+
+module.exports = createExtension;

package/server/services/extension/shadow-crud-manager.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const getDefaultContentTypeConfig = () => ({
+  enabled: true,
+
+  mutations: true,
+  queries: true,
+
+  disabledActions: [],
+  fields: new Map(),
+});
+
+const getDefaultFieldConfig = () => ({
+  enabled: true,
+
+  input: true,
+  output: true,
+
+  filters: true,
+});
+
+const ALL_ACTIONS = '*';
+
+module.exports = () => {
+  const configs = new Map();
+
+  return uid => {
+    if (!configs.has(uid)) {
+      configs.set(uid, getDefaultContentTypeConfig());
+    }
+
+    return {
+      isEnabled() {
+        return configs.get(uid).enabled;
+      },
+
+      isDisabled() {
+        return !this.isEnabled();
+      },
+
+      areQueriesEnabled() {
+        return configs.get(uid).queries;
+      },
+
+      areQueriesDisabled() {
+        return !this.areQueriesEnabled();
+      },
+
+      areMutationsEnabled() {
+        return configs.get(uid).mutations;
+      },
+
+      areMutationsDisabled() {
+        return !this.areMutationsEnabled();
+      },
+
+      isActionEnabled(action) {
+        const matchingActions = [action, ALL_ACTIONS];
+
+        return configs.get(uid).disabledActions.every(action => !matchingActions.includes(action));
+      },
+
+      isActionDisabled(action) {
+        return !this.isActionEnabled(action);
+      },
+
+      disable() {
+        configs.get(uid).enabled = false;
+
+        return this;
+      },
+
+      disableQueries() {
+        configs.get(uid).queries = false;
+
+        return this;
+      },
+
+      disableMutations() {
+        configs.get(uid).mutations = false;
+
+        return this;
+      },
+
+      disableAction(action) {
+        const config = configs.get(uid);
+
+        if (!config.disabledActions.includes(action)) {
+          config.disabledActions.push(action);
+        }
+
+        return this;
+      },
+
+      disableActions(actions = []) {
+        actions.forEach(action => this.disableAction(action));
+
+        return this;
+      },
+
+      field(fieldName) {
+        const { fields } = configs.get(uid);
+
+        if (!fields.has(fieldName)) {
+          fields.set(fieldName, getDefaultFieldConfig());
+        }
+
+        return {
+          isEnabled() {
+            return fields.get(fieldName).enabled;
+          },
+
+          hasInputEnabled() {
+            return fields.get(fieldName).input;
+          },
+
+          hasOutputEnabled() {
+            return fields.get(fieldName).output;
+          },
+
+          hasFiltersEnabeld() {
+            return fields.get(fieldName).filters;
+          },
+
+          disable() {
+            fields.set(fieldName, {
+              enabled: false,
+
+              output: false,
+              input: false,
+
+              filters: false,
+            });
+
+            return this;
+          },
+
+          disableOutput() {
+            fields.get(fieldName).output = false;
+
+            return this;
+          },
+
+          disableInput() {
+            fields.get(fieldName).input = false;
+
+            return this;
+          },
+
+          disableFilters() {
+            fields.get(fieldName).filters = false;
+
+            return this;
+          },
+        };
+      },
+    };
+  };
+};

package/server/services/format/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const returnTypes = require('./return-types');
+
+module.exports = context => ({
+  returnTypes: returnTypes(context),
+});

package/server/services/format/return-types.js

@@ -0,0 +1,27 @@
+'use strict';
+
+module.exports = () => ({
+  /**
+   * @param {object} value
+   * @param {object} info
+   * @param {object} info.args
+   * @param {string} info.resourceUID
+   */
+  toEntityResponse(value, info = {}) {
+    const { args = {}, resourceUID } = info;
+
+    return { value, info: { args, resourceUID } };
+  },
+
+  /**
+   * @param {object[]} nodes
+   * @param {object} info
+   * @param {object} info.args
+   * @param {string} info.resourceUID
+   */
+  toEntityResponseCollection(nodes, info = {}) {
+    const { args = {}, resourceUID } = info;
+
+    return { nodes, info: { args, resourceUID } };
+  },
+});

package/server/services/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const contentAPI = require('./content-api');
+const typeRegistry = require('./type-registry');
+const utils = require('./utils');
+const constants = require('./constants');
+const internals = require('./internals');
+const builders = require('./builders');
+const extension = require('./extension');
+const format = require('./format');
+
+module.exports = {
+  builders,
+  'content-api': contentAPI,
+  constants,
+  extension,
+  format,
+  internals,
+  'type-registry': typeRegistry,
+  utils,
+};

package/server/services/internals/args/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const SortArg = require('./sort');
+const publicationState = require('./publication-state');
+const PaginationArg = require('./pagination');
+
+module.exports = context => ({
+  SortArg,
+  PaginationArg,
+  PublicationStateArg: publicationState(context),
+});

package/server/services/internals/args/pagination.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { arg, inputObjectType } = require('nexus');
+
+const PaginationInputType = inputObjectType({
+  name: 'PaginationArg',
+
+  definition(t) {
+    t.int('page');
+    t.int('pageSize');
+    t.int('start');
+    t.int('limit');
+  },
+});
+
+module.exports = arg({
+  type: PaginationInputType,
+  default: {},
+});

package/server/services/internals/args/publication-state.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { arg } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const { PUBLICATION_STATE_TYPE_NAME } = strapi.plugin('graphql').service('constants');
+
+  return arg({
+    type: PUBLICATION_STATE_TYPE_NAME,
+    default: 'live',
+  });
+};

package/server/services/internals/args/sort.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const { arg, list } = require('nexus');
+
+const SortArg = arg({
+  type: list('String'),
+  default: [],
+});
+
+module.exports = SortArg;

package/server/services/internals/helpers/get-enabled-scalars.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { first } = require('lodash/fp');
+
+module.exports = ({ strapi }) => () => {
+  const { GRAPHQL_SCALAR_OPERATORS } = strapi.plugin('graphql').service('constants');
+
+  return (
+    Object.entries(GRAPHQL_SCALAR_OPERATORS)
+      // To be valid, a GraphQL scalar must have at least one operator enabled
+      .filter(([, value]) => value.length > 0)
+      // Only keep the key (the scalar name)
+      .map(first)
+  );
+};

package/server/services/internals/helpers/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const getEnabledScalars = require('./get-enabled-scalars');
+
+module.exports = context => ({
+  getEnabledScalars: getEnabledScalars(context),
+});

package/server/services/internals/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const args = require('./args');
+const scalars = require('./scalars');
+const types = require('./types');
+const helpers = require('./helpers');
+
+module.exports = context => ({
+  args: args(context),
+  scalars: scalars(context),
+  buildInternalTypes: types(context),
+  helpers: helpers(context),
+});

package/server/services/internals/scalars/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const GraphQLJSON = require('graphql-type-json');
+const GraphQLLong = require('graphql-type-long');
+const { GraphQLDateTime, GraphQLDate } = require('graphql-iso-date/dist');
+const { GraphQLUpload } = require('graphql-upload');
+const { asNexusMethod } = require('nexus');
+
+const TimeScalar = require('./time');
+
+module.exports = () => ({
+  JSON: asNexusMethod(GraphQLJSON, 'json'),
+  DateTime: asNexusMethod(GraphQLDateTime, 'dateTime'),
+  Time: asNexusMethod(TimeScalar, 'time'),
+  Date: asNexusMethod(GraphQLDate, 'date'),
+  Long: asNexusMethod(GraphQLLong, 'long'),
+  Upload: asNexusMethod(GraphQLUpload, 'upload'),
+});

package/server/services/internals/scalars/time.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { GraphQLScalarType } = require('graphql');
+const { Kind } = require('graphql');
+const { parseType } = require('@strapi/utils');
+
+/**
+ * A GraphQL scalar used to store Time (HH:mm:ss.SSS) values
+ * @type {GraphQLScalarType}
+ */
+const TimeScalar = new GraphQLScalarType({
+  name: 'Time',
+
+  description: 'A time string with format HH:mm:ss.SSS',
+
+  serialize(value) {
+    return parseType({ type: 'time', value });
+  },
+
+  parseValue(value) {
+    return parseType({ type: 'time', value });
+  },
+
+  parseLiteral(ast) {
+    if (ast.kind !== Kind.STRING) {
+      throw new TypeError('Time cannot represent non string type');
+    }
+
+    const value = ast.value;
+
+    return parseType({ type: 'time', value });
+  },
+});
+
+module.exports = TimeScalar;

package/server/services/internals/types/error.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { objectType } = require('nexus');
+const { get } = require('lodash/fp');
+
+/**
+ * Build an Error object type
+ * @return {Object<string, NexusObjectTypeDef>}
+ */
+module.exports = ({ strapi }) => {
+  const { ERROR_CODES, ERROR_TYPE_NAME } = strapi.plugin('graphql').service('constants');
+
+  return objectType({
+    name: ERROR_TYPE_NAME,
+
+    definition(t) {
+      t.nonNull.string('code', {
+        resolve(parent) {
+          const code = get('code', parent);
+
+          const isValidPlaceholderCode = Object.values(ERROR_CODES).includes(code);
+          if (!isValidPlaceholderCode) {
+            throw new TypeError(`"${code}" is not a valid code value`);
+          }
+
+          return code;
+        },
+      });
+
+      t.string('message');
+    },
+  });
+};

package/server/services/internals/types/filters.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { inputObjectType } = require('nexus');
+
+/**
+ * Build a map of filters type for every GraphQL scalars
+ * @return {Object<string, NexusInputTypeDef>}
+ */
+const buildScalarFilters = ({ strapi }) => {
+  const { naming, mappers } = strapi.plugin('graphql').service('utils');
+  const { helpers } = strapi.plugin('graphql').service('internals');
+
+  return helpers.getEnabledScalars().reduce((acc, type) => {
+    const operators = mappers.graphqlScalarToOperators(type);
+    const typeName = naming.getScalarFilterInputTypeName(type);
+
+    if (!operators || operators.length === 0) {
+      return acc;
+    }
+
+    return {
+      ...acc,
+
+      [typeName]: inputObjectType({
+        name: typeName,
+
+        definition(t) {
+          for (const operator of operators) {
+            operator.add(t, type);
+          }
+        },
+      }),
+    };
+  }, {});
+};
+
+module.exports = context => ({
+  scalars: buildScalarFilters(context),
+});