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

package/server/services/utils/naming.js

@@ -0,0 +1,282 @@
+'use strict';
+
+const { camelCase, upperFirst, lowerFirst, pipe, get } = require('lodash/fp');
+const { singular } = require('pluralize');
+
+module.exports = ({ strapi }) => {
+  /**
+   * Build a type name for a enum based on a content type & an attribute name
+   * @param {object} contentType
+   * @param {string} attributeName
+   * @return {string}
+   */
+  const getEnumName = (contentType, attributeName) => {
+    const { attributes, modelName } = contentType;
+    const { enumName } = attributes[attributeName];
+
+    const defaultEnumName = `ENUM_${modelName.toUpperCase()}_${attributeName.toUpperCase()}`;
+
+    return enumName || defaultEnumName;
+  };
+
+  /**
+   * Build the base type name for a given content type
+   * @param {object} contentType
+   * @param {object} options
+   * @param {'singular' | 'plural'} options.plurality
+   * @return {string}
+   */
+  const getTypeName = (contentType, { plurality = 'singular' } = {}) => {
+    const plugin = get('plugin', contentType);
+    const modelName = get('modelName', contentType);
+    const name =
+      plurality === 'singular'
+        ? get('info.singularName', contentType)
+        : get('info.pluralName', contentType);
+
+    const transformedPlugin = upperFirst(camelCase(plugin));
+    const transformedModelName = upperFirst(camelCase(name || singular(modelName)));
+
+    return `${transformedPlugin}${transformedModelName}`;
+  };
+
+  /**
+   * Build the entity's type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getEntityName = contentType => {
+    return `${getTypeName(contentType)}Entity`;
+  };
+
+  /**
+   * Build the entity meta type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getEntityMetaName = contentType => {
+    return `${getEntityName(contentType)}Meta`;
+  };
+
+  /**
+   * Build the entity response's type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getEntityResponseName = contentType => {
+    return `${getEntityName(contentType)}Response`;
+  };
+
+  /**
+   * Build the entity response collection's type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getEntityResponseCollectionName = contentType => {
+    return `${getEntityName(contentType)}ResponseCollection`;
+  };
+
+  /**
+   * Build the relation response collection's type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getRelationResponseCollectionName = contentType => {
+    return `${getTypeName(contentType)}RelationResponseCollection`;
+  };
+
+  /**
+   * Build a component type name based on its definition
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getComponentName = contentType => {
+    return contentType.globalId;
+  };
+
+  /**
+   * Build a component type name based on a content type's attribute
+   * @param {object} attribute
+   * @return {string}
+   */
+  const getComponentNameFromAttribute = attribute => {
+    return strapi.components[attribute.component].globalId;
+  };
+
+  /**
+   * Build a dynamic zone type name based on a content type and an attribute name
+   * @param {object} contentType
+   * @param {string} attributeName
+   * @return {string}
+   */
+  const getDynamicZoneName = (contentType, attributeName) => {
+    const typeName = getTypeName(contentType);
+    const dzName = upperFirst(camelCase(attributeName));
+    const suffix = 'DynamicZone';
+
+    return `${typeName}${dzName}${suffix}`;
+  };
+
+  /**
+   * Build a dynamic zone input type name based on a content type and an attribute name
+   * @param {object} contentType
+   * @param {string} attributeName
+   * @return {string}
+   */
+  const getDynamicZoneInputName = (contentType, attributeName) => {
+    const dzName = getDynamicZoneName(contentType, attributeName);
+
+    return `${dzName}Input`;
+  };
+
+  /**
+   * Build a component input type name based on a content type and an attribute name
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getComponentInputName = contentType => {
+    const componentName = getComponentName(contentType);
+
+    return `${componentName}Input`;
+  };
+
+  /**
+   * Build a content type input name based on a content type and an attribute name
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getContentTypeInputName = contentType => {
+    const typeName = getTypeName(contentType);
+
+    return `${typeName}Input`;
+  };
+
+  /**
+   * Build the queries type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getEntityQueriesTypeName = contentType => {
+    return `${getEntityName(contentType)}Queries`;
+  };
+
+  /**
+   * Build the mutations type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getEntityMutationsTypeName = contentType => {
+    return `${getEntityName(contentType)}Mutations`;
+  };
+
+  /**
+   * Build the filters type name for a given content type
+   * @param {object} contentType
+   * @return {string}
+   */
+  const getFiltersInputTypeName = contentType => {
+    const isComponent = contentType.modelType === 'component';
+
+    const baseName = isComponent ? getComponentName(contentType) : getTypeName(contentType);
+
+    return `${baseName}FiltersInput`;
+  };
+
+  /**
+   * Build a filters type name for a given GraphQL scalar type
+   * @param {NexusGenScalars} scalarType
+   * @return {string}
+   */
+  const getScalarFilterInputTypeName = scalarType => {
+    return `${scalarType}FilterInput`;
+  };
+
+  /**
+   * Build a type name for a given content type & polymorphic attribute
+   * @param {object} contentType
+   * @param {string} attributeName
+   * @return {string}
+   */
+  const getMorphRelationTypeName = (contentType, attributeName) => {
+    const typeName = getTypeName(contentType);
+    const formattedAttr = upperFirst(camelCase(attributeName));
+
+    return `${typeName}${formattedAttr}Morph`;
+  };
+
+  /**
+   * Build a custom type name generator with different customization options
+   * @param {object} options
+   * @param {string} [options.prefix]
+   * @param {string} [options.suffix]
+   * @param {'upper' | 'lower'} [options.firstLetterCase]
+   * @param {'plural' | 'singular'} [options.plurality]
+   * @return {function(*=): string}
+   */
+  const buildCustomTypeNameGenerator = (options = {}) => {
+    // todo[v4]: use singularName & pluralName is available
+    const { prefix = '', suffix = '', plurality = 'singular', firstLetterCase = 'upper' } = options;
+
+    if (!['plural', 'singular'].includes(plurality)) {
+      throw new Error(
+        `"plurality" param must be either "plural" or "singular", but got: "${plurality}"`
+      );
+    }
+
+    const getCustomTypeName = pipe(
+      ct => getTypeName(ct, { plurality }),
+      firstLetterCase === 'upper' ? upperFirst : lowerFirst
+    );
+
+    return contentType => `${prefix}${getCustomTypeName(contentType)}${suffix}`;
+  };
+
+  const getFindQueryName = buildCustomTypeNameGenerator({
+    plurality: 'plural',
+    firstLetterCase: 'lower',
+  });
+
+  const getFindOneQueryName = buildCustomTypeNameGenerator({ firstLetterCase: 'lower' });
+
+  const getCreateMutationTypeName = buildCustomTypeNameGenerator({
+    prefix: 'create',
+    firstLetterCase: 'upper',
+  });
+
+  const getUpdateMutationTypeName = buildCustomTypeNameGenerator({
+    prefix: 'update',
+    firstLetterCase: 'upper',
+  });
+
+  const getDeleteMutationTypeName = buildCustomTypeNameGenerator({
+    prefix: 'delete',
+    firstLetterCase: 'upper',
+  });
+
+  return {
+    getEnumName,
+    getTypeName,
+    getEntityName,
+    getEntityMetaName,
+    getEntityResponseName,
+    getEntityResponseCollectionName,
+    getRelationResponseCollectionName,
+    getComponentName,
+    getComponentNameFromAttribute,
+    getDynamicZoneName,
+    getDynamicZoneInputName,
+    getComponentInputName,
+    getContentTypeInputName,
+    getEntityQueriesTypeName,
+    getEntityMutationsTypeName,
+    getFiltersInputTypeName,
+    getScalarFilterInputTypeName,
+    getMorphRelationTypeName,
+    buildCustomTypeNameGenerator,
+    getFindQueryName,
+    getFindOneQueryName,
+    getCreateMutationTypeName,
+    getUpdateMutationTypeName,
+    getDeleteMutationTypeName,
+  };
+};

package/strapi-admin.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./admin/src').default;

package/strapi-server.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const bootstrap = require('./server/bootstrap');
+const services = require('./server/services');
+
+module.exports = (/* strapi, config */) => {
+  return {
+    bootstrap,
+    services,
+  };
+};

package/config/routes.json

@@ -1,3 +0,0 @@
-{
-  "routes": []
-}

package/config/schema.graphql

@@ -1 +0,0 @@
-module.exports = {};

package/config/settings.json

@@ -1,12 +0,0 @@
-{
-  "endpoint": "/graphql",
-  "shadowCRUD": true,
-  "playgroundAlways": false,
-  "depthLimit": 7,
-  "amountLimit": 100,
-  "shareEnabled": false,
-  "federation": false,
-  "apolloServer": {
-    "tracing": false
-  }
-}

package/controllers/GraphQL.js

@@ -1,9 +0,0 @@
-'use strict';
-
-/**
- * GraphQL.js controller
- *
- * @description: A set of functions called "actions" of the `GraphQL` plugin.
- */
-
-module.exports = {};

package/hooks/graphql/defaults.json

@@ -1,5 +0,0 @@
-{
-  "graphql": {
-    "enabled": true
-  }
-}

package/hooks/graphql/index.js

@@ -1,174 +0,0 @@
-'use strict';
-
-/**
- * Module dependencies
- */
-
-// Public node modules.
-const _ = require('lodash');
-const { ApolloServer } = require('apollo-server-koa');
-const depthLimit = require('graphql-depth-limit');
-const { graphqlUploadKoa } = require('graphql-upload');
-const loadConfigs = require('./load-config');
-
-const attachMetadataToResolvers = (schema, { api, plugin }) => {
-  const { resolver = {} } = schema;
-  if (_.isEmpty(resolver)) return schema;
-
-  Object.keys(resolver).forEach(type => {
-    if (!_.isPlainObject(resolver[type])) return;
-
-    Object.keys(resolver[type]).forEach(resolverName => {
-      if (!_.isPlainObject(resolver[type][resolverName])) return;
-
-      resolver[type][resolverName]['_metadatas'] = {
-        api,
-        plugin,
-      };
-    });
-  });
-
-  return schema;
-};
-
-module.exports = strapi => {
-  const { appPath, installedPlugins } = strapi.config;
-
-  return {
-    async beforeInitialize() {
-      // Try to inject this hook just after the others hooks to skip the router processing.
-      if (!strapi.config.get('hook.load.after')) {
-        _.set(strapi.config.hook.load, 'after', []);
-      }
-
-      strapi.config.hook.load.after.push('graphql');
-      // Load core utils.
-
-      const { api, plugins, extensions } = await loadConfigs({
-        appPath,
-        installedPlugins,
-      });
-      _.merge(strapi, { api, plugins });
-
-      // Create a merge of all the GraphQL configuration.
-      const apisSchemas = Object.keys(strapi.api || {}).map(key => {
-        const schema = _.get(strapi.api[key], 'config.schema.graphql', {});
-        return attachMetadataToResolvers(schema, { api: key });
-      });
-
-      const pluginsSchemas = Object.keys(strapi.plugins || {}).map(key => {
-        const schema = _.get(strapi.plugins[key], 'config.schema.graphql', {});
-        return attachMetadataToResolvers(schema, { plugin: key });
-      });
-
-      const extensionsSchemas = Object.keys(extensions || {}).map(key => {
-        const schema = _.get(extensions[key], 'config.schema.graphql', {});
-        return attachMetadataToResolvers(schema, { plugin: key });
-      });
-
-      const baseSchema = mergeSchemas([...pluginsSchemas, ...extensionsSchemas, ...apisSchemas]);
-
-      // save the final schema in the plugin's config
-      _.set(strapi.plugins.graphql, 'config._schema.graphql', baseSchema);
-    },
-
-    initialize() {
-      const schema = strapi.plugins.graphql.services['schema-generator'].generateSchema();
-
-      if (_.isEmpty(schema)) {
-        strapi.log.warn('The GraphQL schema has not been generated because it is empty');
-
-        return;
-      }
-
-      const config = _.get(strapi.plugins.graphql, 'config', {});
-
-      // TODO: Remove these deprecated options in favor of `apolloServer` in the next major version
-      const deprecatedApolloServerConfig = {
-        tracing: _.get(config, 'tracing', false),
-        introspection: _.get(config, 'introspection', true),
-        engine: _.get(config, 'engine', false),
-      };
-
-      if (['tracing', 'introspection', 'engine'].some(key => _.has(config, key))) {
-        strapi.log.warn(
-          'The `tracing`, `introspection` and `engine` options are deprecated in favor of the `apolloServer` object and they will be removed in the next major version.'
-        );
-      }
-
-      const apolloServerConfig = _.get(config, 'apolloServer', {});
-
-      const serverParams = {
-        schema,
-        uploads: false,
-        context: ({ ctx }) => {
-          // Initiliase loaders for this request.
-          // TODO: set loaders in the context not globally
-
-          strapi.plugins.graphql.services['data-loaders'].initializeLoader();
-
-          return {
-            context: ctx,
-          };
-        },
-        formatError: err => {
-          const formatError = _.get(config, 'formatError', null);
-
-          return typeof formatError === 'function' ? formatError(err) : err;
-        },
-        validationRules: [depthLimit(config.depthLimit)],
-        playground: false,
-        cors: false,
-        bodyParserConfig: true,
-        // TODO: Remove these deprecated options in favor of `apolloServerConfig` in the next major version
-        ...deprecatedApolloServerConfig,
-        ...apolloServerConfig,
-      };
-
-      // Disable GraphQL Playground in production environment.
-      if (strapi.config.environment !== 'production' || config.playgroundAlways) {
-        serverParams.playground = {
-          endpoint: `${strapi.config.server.url}${config.endpoint}`,
-          shareEnabled: config.shareEnabled,
-        };
-      }
-
-      const server = new ApolloServer(serverParams);
-
-      const uploadMiddleware = graphqlUploadKoa();
-      strapi.app.use((ctx, next) => {
-        if (ctx.path === config.endpoint) {
-          return uploadMiddleware(ctx, next);
-        }
-
-        return next();
-      });
-      server.applyMiddleware({
-        app: strapi.app,
-        path: config.endpoint,
-      });
-
-      strapi.plugins.graphql.destroy = async () => {
-        await server.stop();
-      };
-    },
-  };
-};
-
-/**
- * Merges a  list of schemas
- * @param {Array<Object>} schemas - The list of schemas to merge
- */
-const mergeSchemas = schemas => {
-  return schemas.reduce((acc, el) => {
-    const { definition, query, mutation, type, resolver } = el;
-
-    return _.merge(acc, {
-      definition: `${acc.definition || ''} ${definition || ''}`,
-      query: `${acc.query || ''} ${query || ''}`,
-      mutation: `${acc.mutation || ''} ${mutation || ''}`,
-      type,
-      resolver,
-    });
-  }, {});
-};

package/hooks/graphql/load-config.js

@@ -1,42 +0,0 @@
-'use strict';
-
-// eslint-disable-next-line node/no-extraneous-require
-const loadUtils = require('@strapi/strapi/lib/load');
-const _ = require('lodash');
-
-const loadApisGraphqlConfig = appPath =>
-  loadUtils.loadFiles(appPath, 'api/**/config/*.graphql?(.js)');
-
-const loadPluginsGraphqlConfig = async installedPlugins => {
-  const root = {};
-
-  for (let pluginName of installedPlugins) {
-    const pluginDir = loadUtils.findPackagePath(`@strapi/plugin-${pluginName}`);
-
-    const result = await loadUtils.loadFiles(pluginDir, 'config/*.graphql?(.js)');
-
-    _.set(root, ['plugins', pluginName], result);
-  }
-
-  return root;
-};
-
-const loadLocalPluginsGraphqlConfig = async appPath =>
-  loadUtils.loadFiles(appPath, 'plugins/**/config/*.graphql?(.js)');
-
-const loadExtensions = async appPath =>
-  loadUtils.loadFiles(appPath, 'extensions/**/config/*.graphql?(.js)');
-
-/**
- * Loads the graphql config files
- */
-module.exports = async ({ appPath, installedPlugins }) => {
-  const [apis, plugins, localPlugins, extensions] = await Promise.all([
-    loadApisGraphqlConfig(appPath),
-    loadPluginsGraphqlConfig(installedPlugins),
-    loadLocalPluginsGraphqlConfig(appPath),
-    loadExtensions(appPath),
-  ]);
-
-  return _.merge({}, apis, plugins, extensions, localPlugins);
-};