@strapi/plugin-graphql 4.15.5-alpha.6 → 4.16.0

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

@@ -1,69 +0,0 @@
-'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

@@ -1,14 +0,0 @@
-'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

@@ -1,72 +0,0 @@
-'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

@@ -1,148 +0,0 @@
-'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',
-];
-
-/**
- * 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);
-    }
-
-    throw new Error(
-      `Invalid middleware type, expected (function,string,object), received ${typeof middleware}`
-    );
-  });
-};
-
-/**
- * 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;
-};
-
-module.exports = { wrapResolvers };

package/server/services/extension/extension.js

@@ -1,94 +0,0 @@
-'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

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

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

@@ -1,161 +0,0 @@
-'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

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

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

@@ -1,27 +0,0 @@
-'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

@@ -1,21 +0,0 @@
-'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

@@ -1,11 +0,0 @@
-'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

@@ -1,19 +0,0 @@
-'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

@@ -1,12 +0,0 @@
-'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

@@ -1,10 +0,0 @@
-'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

@@ -1,17 +0,0 @@
-'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)
-    );
-  };