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

package/services/resolvers-builder.js

@@ -1,204 +0,0 @@
-/**
- * Build queries and mutation resolvers
- */
-
-'use strict';
-
-const _ = require('lodash');
-const compose = require('koa-compose');
-
-const { policy: policyUtils } = require('@strapi/utils');
-const {
-  convertToParams,
-  convertToQuery,
-  amountLimiting,
-  getAction,
-  getActionDetails,
-  isResolvablePath,
-} = require('./utils');
-
-const buildMutation = (mutationName, config) => {
-  const { resolver, resolverOf, transformOutput = _.identity, isShadowCrud = false } = config;
-
-  if (_.isFunction(resolver) && !isResolvablePath(resolverOf)) {
-    throw new Error(
-      `Cannot create mutation "${mutationName}". Missing "resolverOf" option with custom resolver.`
-    );
-  }
-
-  const policiesMiddleware = compose(getPolicies(config));
-
-  // custom resolvers
-  if (_.isFunction(resolver)) {
-    return async (root, options = {}, graphqlContext, info) => {
-      const ctx = buildMutationContext({ options, graphqlContext, isShadowCrud });
-
-      await policiesMiddleware(ctx);
-      graphqlContext.context = ctx;
-
-      return resolver(root, options, graphqlContext, info);
-    };
-  }
-
-  const action = getAction(resolver);
-
-  return async (root, options = {}, graphqlContext) => {
-    const ctx = buildMutationContext({ options, graphqlContext, isShadowCrud });
-
-    await policiesMiddleware(ctx);
-
-    const values = await action(ctx);
-    const result = ctx.body !== undefined ? ctx.body : values;
-
-    if (_.isError(result)) {
-      throw result;
-    }
-
-    return transformOutput(result);
-  };
-};
-
-const buildMutationContext = ({ options, graphqlContext, isShadowCrud }) => {
-  const { context } = graphqlContext;
-
-  const ctx = cloneKoaContext(context);
-
-  if (options.input && options.input.where) {
-    ctx.params = convertToParams(options.input.where || {});
-  } else {
-    ctx.params = {};
-  }
-
-  if (options.input && options.input.data) {
-    ctx.request.body = options.input.data || {};
-  } else {
-    ctx.request.body = options;
-  }
-
-  if (isShadowCrud) {
-    ctx.query = convertToParams(_.omit(options, 'input'));
-  }
-
-  return ctx;
-};
-
-const buildQuery = (queryName, config) => {
-  const { resolver } = config;
-
-  try {
-    validateResolverOption(config);
-  } catch (error) {
-    throw new Error(`Cannot create query "${queryName}": ${error.message}`);
-  }
-
-  const policiesMiddleware = compose(getPolicies(config));
-
-  // custom resolvers
-  if (_.isFunction(resolver)) {
-    return async (root, options = {}, graphqlContext, info) => {
-      const { ctx, opts } = buildQueryContext({ options, graphqlContext });
-
-      await policiesMiddleware(ctx);
-      graphqlContext.context = ctx;
-
-      return resolver(root, opts, graphqlContext, info);
-    };
-  }
-
-  const action = getAction(resolver);
-
-  return async (root, options = {}, graphqlContext) => {
-    const { ctx } = buildQueryContext({ options, graphqlContext });
-
-    // duplicate context
-    await policiesMiddleware(ctx);
-
-    const values = await action(ctx);
-    const result = ctx.body !== undefined ? ctx.body : values;
-
-    if (_.isError(result)) {
-      throw result;
-    }
-
-    return result;
-  };
-};
-
-const validateResolverOption = config => {
-  const { resolver, resolverOf, policies } = config;
-
-  if (_.isFunction(resolver) && !isResolvablePath(resolverOf)) {
-    throw new Error(`Missing "resolverOf" option with custom resolver.`);
-  }
-
-  if (!_.isUndefined(policies) && (!Array.isArray(policies) || !_.every(policies, _.isString))) {
-    throw new Error('Policies option must be an array of string.');
-  }
-
-  return true;
-};
-
-const cloneKoaContext = ctx => {
-  return Object.assign(ctx.app.createContext(_.clone(ctx.req), _.clone(ctx.res)), {
-    state: {
-      ...ctx.state,
-    },
-  });
-};
-
-const buildQueryContext = ({ options, graphqlContext }) => {
-  const { context } = graphqlContext;
-  const _options = _.cloneDeep(options);
-
-  const ctx = cloneKoaContext(context);
-
-  const opts = amountLimiting(_options);
-
-  ctx.query = {
-    ...convertToParams(_.omit(opts, 'where')),
-    ...convertToQuery(opts.where),
-  };
-
-  ctx.params = convertToParams(opts);
-
-  return { ctx, opts };
-};
-
-/**
- * Checks if a resolverPath (resolver or resovlerOf) might be resolved
- */
-const getPolicies = config => {
-  const { resolver, policies = [], resolverOf } = config;
-
-  const { api, plugin } = config['_metadatas'] || {};
-
-  const policyFns = [];
-
-  const { controller, action, plugin: pathPlugin } = isResolvablePath(resolverOf)
-    ? getActionDetails(resolverOf)
-    : getActionDetails(resolver);
-
-  const globalPolicy = policyUtils.globalPolicy({
-    controller,
-    action,
-    plugin: pathPlugin,
-  });
-
-  policyFns.push(globalPolicy);
-
-  if (strapi.plugins['users-permissions']) {
-    policies.unshift('plugin::users-permissions.permissions');
-  }
-
-  policies.forEach(policy => {
-    const policyFn = policyUtils.get(policy, plugin, api);
-    policyFns.push(policyFn);
-  });
-
-  return policyFns;
-};
-
-module.exports = {
-  buildQuery,
-  buildMutation,
-};

package/services/schema-definitions.js

@@ -1,131 +0,0 @@
-/**
- * Schema definition language tools
- */
-
-'use strict';
-
-const _ = require('lodash');
-
-/**
- * Retrieves a type description from its configuration or its related model
- * @return String
- */
-const getTypeDescription = (type, model = {}) => {
-  const str = _.get(type, '_description') || _.get(model, 'info.description');
-
-  if (str) {
-    return `"""\n${str}\n"""\n`;
-  }
-
-  return '';
-};
-
-/**
- * Receive an Object and return a string which is following the GraphQL specs.
- * @param {Object} fields
- * @param {Object} description
- * @param {Object} model the underlying strapi model of those fields
- * @param {string} type the type of object we are converting to SQL (query, mutation, or fields)
- */
-const toSDL = (fields, configurations = {}, model = {}, type = 'field') => {
-  if (['query', 'mutation'].includes(type)) {
-    return operationToSDL({ fields, configurations });
-  }
-
-  return fieldsToSDL({ fields, model, configurations });
-};
-
-/**
- * Generated a SDL for a type
- * @param {Object} options
- * @param {Object} options.fields fields to convert to SDL
- * @param {Object} options.configurations fields configurations (descriptions and deprecations)
- * @param {Object} options.model the underlying strapi model of those fields
- */
-const fieldsToSDL = ({ fields, configurations, model }) => {
-  return Object.entries(fields)
-    .map(([key, value]) => {
-      const [attr] = key.split('(');
-      const attributeName = _.trim(attr);
-
-      const description = _.isString(configurations[attributeName])
-        ? configurations[attributeName]
-        : _.get(configurations, [attributeName, 'description']) ||
-          _.get(model, ['attributes', attributeName, 'description']);
-
-      const deprecated =
-        _.get(configurations, [attributeName, 'deprecated']) ||
-        _.get(model, ['attributes', attributeName, 'deprecated']);
-
-      return applyMetadatas(`${key}: ${value}`, { description, deprecated });
-    })
-    .join('\n');
-};
-
-/**
- * Generated a SDL for a query or a mutation object
- * @param {Object} options
- * @param {Object} options.fields fields to convert to SDL
- * @param {Object} options.configurations fields configurations (descriptions and deprecations)
- */
-const operationToSDL = ({ fields, configurations }) => {
-  return Object.entries(fields)
-    .map(([key, value]) => {
-      if (typeof value === 'string') {
-        const [attr] = key.split('(');
-        const attributeName = _.trim(attr);
-
-        return applyMetadatas(`${key}: ${value}`, configurations[attributeName]);
-      } else {
-        const { args = {}, type } = value;
-
-        const query = `${key}${argumentsToSDL(args)}: ${type}`;
-        return applyMetadatas(query, configurations[key]);
-      }
-    })
-    .join('\n');
-};
-
-/**
- * Converts an object of arguments into graphql SDL
- * @param {object} args arguments
- * @returns {string}
- */
-const argumentsToSDL = args => {
-  if (_.isEmpty(args)) {
-    return '';
-  }
-
-  const sdlArgs = Object.entries(args)
-    .map(([key, value]) => `${key}: ${value}`)
-    .join(', ');
-
-  return `(${sdlArgs})`;
-};
-
-/**
- * Applies description and deprecated to a field definition
- * @param {string} definition field definition
- * @param {Object} metadatas field metadatas
- * @param {string} metadatas.description field description
- * @param {string} metadatas.deprecated field deprecation
- */
-const applyMetadatas = (definition, metadatas = {}) => {
-  const { description, deprecated } = metadatas;
-
-  let tmpDef = definition;
-  if (description) {
-    tmpDef = `"""\n${description}\n"""\n${tmpDef}`;
-  }
-
-  if (deprecated) {
-    tmpDef = `${tmpDef} @deprecated(reason: "${deprecated}")`;
-  }
-
-  return tmpDef;
-};
-
-module.exports = {
-  toSDL,
-  getTypeDescription,
-};

package/services/schema-generator.js

@@ -1,178 +0,0 @@
-'use strict';
-
-/**
- * GraphQL.js service
- *
- * @description: A set of functions similar to controller's actions to avoid code duplication.
- */
-const { filterSchema } = require('@graphql-tools/utils');
-const { buildFederatedSchema } = require('@apollo/federation');
-const { gql, makeExecutableSchema } = require('apollo-server-koa');
-const _ = require('lodash');
-const graphql = require('graphql');
-const PublicationState = require('../types/publication-state');
-const Types = require('./type-builder');
-const buildShadowCrud = require('./shadow-crud');
-const { createDefaultSchema, diffResolvers } = require('./utils');
-const { toSDL } = require('./schema-definitions');
-const { buildQuery, buildMutation } = require('./resolvers-builder');
-
-/**
- * Generate GraphQL schema.
- *
- * @return Schema
- */
-
-const generateSchema = () => {
-  const isFederated = _.get(strapi.plugins.graphql.config, 'federation', false);
-  const shadowCRUDEnabled = strapi.plugins.graphql.config.shadowCRUD !== false;
-
-  const _schema = strapi.plugins.graphql.config._schema.graphql;
-
-  const ctx = {
-    schema: _schema,
-  };
-
-  // Generate type definition and query/mutation for models.
-  const shadowCRUD = shadowCRUDEnabled ? buildShadowCrud(ctx) : createDefaultSchema();
-
-  // Extract custom definition, query or resolver.
-  const { definition, query, mutation, resolver = {} } = _schema;
-
-  // Polymorphic.
-  const polymorphicSchema = Types.addPolymorphicUnionType(definition + shadowCRUD.definition);
-
-  const builtResolvers = _.merge({}, shadowCRUD.resolvers, polymorphicSchema.resolvers);
-
-  const extraResolvers = diffResolvers(_schema.resolver, builtResolvers);
-
-  const resolvers = _.merge({}, builtResolvers, buildResolvers(extraResolvers));
-
-  // Return empty schema when there is no model.
-  if (_.isEmpty(shadowCRUD.definition) && _.isEmpty(definition)) {
-    return {};
-  }
-
-  const queryFields = shadowCRUD.query && toSDL(shadowCRUD.query, resolver.Query, null, 'query');
-
-  const mutationFields =
-    shadowCRUD.mutation && toSDL(shadowCRUD.mutation, resolver.Mutation, null, 'mutation');
-
-  Object.assign(resolvers, PublicationState.resolver);
-
-  const scalars = Types.getScalars();
-
-  Object.assign(resolvers, scalars);
-
-  const scalarDef = Object.keys(scalars)
-    .map(key => `scalar ${key}`)
-    .join('\n');
-
-  // Concatenate.
-  // Manually defined to avoid exposing all attributes (like password etc.)
-  let typeDefs = `
-      ${definition}
-      ${shadowCRUD.definition}
-      ${polymorphicSchema.definition}
-      ${Types.addInput()}
-
-      ${PublicationState.definition}
-
-      type AdminUser {
-        id: ID!
-        username: String
-        firstname: String!
-        lastname: String!
-      }
-
-      type Query {
-        ${queryFields}
-        ${query}
-      }
-
-      type Mutation {
-        ${mutationFields}
-        ${mutation}
-      }
-      ${scalarDef}
-    `;
-
-  // Build schema.
-  const schema = makeExecutableSchema({
-    typeDefs,
-    resolvers,
-  });
-
-  const generatedSchema = filterDisabledResolvers(schema, extraResolvers);
-
-  if (strapi.config.environment !== 'production') {
-    writeGenerateSchema(generatedSchema);
-  }
-
-  return isFederated ? getFederatedSchema(generatedSchema, resolvers) : generatedSchema;
-};
-
-const getFederatedSchema = (schema, resolvers) =>
-  buildFederatedSchema([{ typeDefs: gql(graphql.printSchema(schema)), resolvers }]);
-
-const filterDisabledResolvers = (schema, extraResolvers) =>
-  filterSchema({
-    schema,
-    rootFieldFilter: (operationName, fieldName) => {
-      const resolver = _.get(extraResolvers[operationName], fieldName, true);
-
-      // resolvers set to false are filtered from the schema
-      if (resolver === false) {
-        return false;
-      }
-      return true;
-    },
-  });
-
-/**
- * Save into a file the readable GraphQL schema.
- *
- * @return void
- */
-const writeGenerateSchema = schema => {
-  const printSchema = graphql.printSchema(schema);
-  return strapi.fs.writeAppFile('exports/graphql/schema.graphql', printSchema);
-};
-
-const buildResolvers = resolvers => {
-  // Transform object to only contain function.
-  return Object.keys(resolvers).reduce((acc, type) => {
-    if (graphql.isScalarType(resolvers[type])) {
-      return acc;
-    }
-
-    return Object.keys(resolvers[type]).reduce((acc, resolverName) => {
-      const resolverObj = resolvers[type][resolverName];
-
-      // Disabled this query.
-      if (resolverObj === false) return acc;
-
-      if (_.isFunction(resolverObj)) {
-        return _.set(acc, [type, resolverName], resolverObj);
-      }
-
-      switch (type) {
-        case 'Mutation': {
-          _.set(acc, [type, resolverName], buildMutation(resolverName, resolverObj));
-
-          break;
-        }
-        default: {
-          _.set(acc, [type, resolverName], buildQuery(resolverName, resolverObj));
-          break;
-        }
-      }
-
-      return acc;
-    }, acc);
-  }, {});
-};
-
-module.exports = {
-  generateSchema,
-};