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

package/server/services/content-api/register-functions/polymorphic.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { unionType } = require('nexus');
+
+const registerPolymorphicContentType = (contentType, { registry, strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const {
+    naming,
+    attributes: { isMorphRelation },
+  } = getService('utils');
+  const { KINDS } = getService('constants');
+
+  const { attributes = {} } = contentType;
+
+  // Isolate its polymorphic attributes
+  const morphAttributes = Object.entries(attributes).filter(([, attribute]) =>
+    isMorphRelation(attribute)
+  );
+
+  // For each one of those polymorphic attribute
+  for (const [attributeName, attribute] of morphAttributes) {
+    const name = naming.getMorphRelationTypeName(contentType, attributeName);
+    const { target } = attribute;
+
+    // Ignore those whose target is not an array
+    if (!Array.isArray(target)) {
+      continue;
+    }
+
+    // Transform target UIDs into types names
+    const members = target
+      // Get content types definitions
+      .map(uid => strapi.getModel(uid))
+      // Resolve types names
+      .map(contentType => naming.getTypeName(contentType));
+
+    // Register the new polymorphic union type
+    registry.register(
+      name,
+
+      unionType({
+        name,
+
+        resolveType(obj) {
+          const contentType = strapi.getModel(obj.__type);
+
+          if (!contentType) {
+            return null;
+          }
+
+          if (contentType.modelType === 'component') {
+            return naming.getComponentName(contentType);
+          }
+
+          return naming.getTypeName(contentType);
+        },
+
+        definition(t) {
+          t.members(...members);
+        },
+      }),
+
+      { kind: KINDS.morph, contentType, attributeName }
+    );
+  }
+};
+
+module.exports = { registerPolymorphicContentType };

package/server/services/content-api/register-functions/scalars.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const registerScalars = ({ registry, strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { scalars } = getService('internals');
+  const { KINDS } = getService('constants');
+
+  Object.entries(scalars).forEach(([name, definition]) => {
+    registry.register(name, definition, { kind: KINDS.scalar });
+  });
+};
+
+module.exports = { registerScalars };

package/server/services/content-api/register-functions/single-type.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const registerSingleType = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { KINDS } = getService('constants');
+
+  const extension = getService('extension');
+
+  const types = {
+    base: naming.getTypeName(contentType),
+    entity: naming.getEntityName(contentType),
+    response: naming.getEntityResponseName(contentType),
+    responseCollection: naming.getEntityResponseCollectionName(contentType),
+    relationResponseCollection: naming.getRelationResponseCollectionName(contentType),
+    queries: naming.getEntityQueriesTypeName(contentType),
+    mutations: naming.getEntityMutationsTypeName(contentType),
+  };
+
+  const getConfig = kind => ({ kind, contentType });
+
+  // Single type's definition
+  registry.register(types.base, builders.buildTypeDefinition(contentType), getConfig(KINDS.type));
+
+  // Higher level entity definition
+  registry.register(
+    types.entity,
+    builders.buildEntityDefinition(contentType),
+    getConfig(KINDS.entity)
+  );
+
+  // Responses definition
+  registry.register(
+    types.response,
+    builders.buildResponseDefinition(contentType),
+    getConfig(KINDS.entityResponse)
+  );
+
+  // Response collection definition
+  registry.register(
+    types.responseCollection,
+    builders.buildResponseCollectionDefinition(contentType),
+    getConfig(KINDS.entityResponseCollection)
+  );
+
+  registry.register(
+    types.relationResponseCollection,
+    builders.buildRelationResponseCollectionDefinition(contentType),
+    getConfig(KINDS.relationResponseCollection)
+  );
+
+  if (extension.shadowCRUD(contentType.uid).areQueriesEnabled()) {
+    // Queries
+    registry.register(
+      types.queries,
+      builders.buildSingleTypeQueries(contentType),
+      getConfig(KINDS.query)
+    );
+  }
+
+  if (extension.shadowCRUD(contentType.uid).areMutationsEnabled()) {
+    // Mutations
+    registry.register(
+      types.mutations,
+      builders.buildSingleTypeMutations(contentType),
+      getConfig(KINDS.mutation)
+    );
+  }
+};
+
+module.exports = { registerSingleType };

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

@@ -0,0 +1,144 @@
+'use strict';
+
+const { get, getOr, isFunction, first, isNil } = require('lodash/fp');
+
+const { GraphQLObjectType } = require('graphql');
+const { ForbiddenError } = require('@strapi/utils').errors;
+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();
+
+  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 isValidType = ['Mutation', 'Query', 'Subscription'].includes(type);
+        const hasConfig = !isNil(authConfig);
+
+        const isAuthDisabled = authConfig === false;
+
+        if ((isValidType || hasConfig) && !isAuthDisabled) {
+          try {
+            await strapi.auth.verify(authContext, authConfig);
+          } catch (error) {
+            throw new ForbiddenError();
+          }
+        }
+      };
+
+      /**
+       * 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)
+  );
+};