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

package/server/services/builders/type.js

@@ -0,0 +1,370 @@
+'use strict';
+
+const { isArray, isString, isUndefined, constant } = require('lodash/fp');
+const { objectType } = require('nexus');
+
+const { contentTypes } = require('@strapi/utils');
+
+/**
+ * @typedef TypeBuildersOptions
+ *
+ * @property {ObjectDefinitionBlock} builder
+ * @property {string} attributeName
+ * @property {object} attribute
+ * @property {object} contentType
+ * @property {object} context
+ * @property {object} context.strapi
+ * @property {object} context.registry
+ */
+module.exports = context => {
+  const { strapi } = context;
+
+  const getGraphQLService = strapi.plugin('graphql').service;
+
+  const extension = getGraphQLService('extension');
+
+  /**
+   * Add a scalar attribute to the type definition
+   *
+   * The attribute is added based on a simple association between a Strapi
+   * type and a GraphQL type (the map is defined in `strapiTypeToGraphQLScalar`)
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addScalarAttribute = ({ builder, attributeName, attribute }) => {
+    const { mappers } = getGraphQLService('utils');
+
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+    builder.field(attributeName, { type: gqlType });
+  };
+
+  /**
+   * Add a component attribute to the type definition
+   *
+   * The attribute is added by fetching the component's type
+   * name and using it as the attribute's type
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addComponentAttribute = ({ builder, attributeName, contentType, attribute }) => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildComponentResolver } = getGraphQLService('builders').get('content-api');
+
+    const type = naming.getComponentNameFromAttribute(attribute);
+
+    if (attribute.repeatable) {
+      builder = builder.list;
+    }
+
+    const targetComponent = strapi.getModel(attribute.component);
+
+    const resolve = buildComponentResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    const args = getContentTypeArgs(targetComponent);
+
+    builder.field(attributeName, { type, resolve, args });
+  };
+
+  /**
+   * Add a dynamic zone attribute to the type definition
+   *
+   * The attribute is added by fetching the dynamic zone's
+   * type name and using it as the attribute's type
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addDynamicZoneAttribute = ({ builder, attributeName, contentType }) => {
+    const { naming } = getGraphQLService('utils');
+    const { ERROR_CODES } = getGraphQLService('constants');
+    const { buildDynamicZoneResolver } = getGraphQLService('builders').get('content-api');
+
+    const { components } = contentType.attributes[attributeName];
+
+    const isEmpty = components.length === 0;
+    const type = naming.getDynamicZoneName(contentType, attributeName);
+
+    const resolve = isEmpty
+      ? // If the dynamic zone don't have any component, then return an error payload
+        constant({
+          code: ERROR_CODES.emptyDynamicZone,
+          message: `This dynamic zone don't have any component attached to it`,
+        })
+      : //  Else, return a classic dynamic-zone resolver
+        buildDynamicZoneResolver({
+          contentTypeUID: contentType.uid,
+          attributeName,
+        });
+
+    builder.list.field(attributeName, { type, resolve });
+  };
+
+  /**
+   * Add an enum attribute to the type definition
+   *
+   * The attribute is added by fetching the enum's type
+   * name and using it as the attribute's type
+   *
+   * @param {TypeBuildersOptions} options
+   */
+  const addEnumAttribute = ({ builder, attributeName, contentType }) => {
+    const { naming } = getGraphQLService('utils');
+
+    const type = naming.getEnumName(contentType, attributeName);
+
+    builder.field(attributeName, { type });
+  };
+
+  /**
+   * Add a media attribute to the type definition
+   * @param {TypeBuildersOptions} options
+   */
+  const addMediaAttribute = options => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    const extension = getGraphQLService('extension');
+
+    let { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+    const fileUID = 'plugin::upload.file';
+
+    if (extension.shadowCRUD(fileUID).isDisabled()) {
+      return;
+    }
+
+    const fileContentType = strapi.contentTypes[fileUID];
+
+    const resolve = buildAssociationResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    const args = attribute.multiple ? getContentTypeArgs(fileContentType) : undefined;
+    const type = attribute.multiple
+      ? naming.getRelationResponseCollectionName(fileContentType)
+      : naming.getEntityResponseName(fileContentType);
+
+    builder.field(attributeName, { type, resolve, args });
+  };
+
+  /**
+   * Add a polymorphic relational attribute to the type definition
+   * @param {TypeBuildersOptions} options
+   */
+  const addPolymorphicRelationalAttribute = options => {
+    const { GENERIC_MORPH_TYPENAME } = getGraphQLService('constants');
+    const { naming } = getGraphQLService('utils');
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+
+    let { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+
+    const { target } = attribute;
+    const isToManyRelation = attribute.relation.endsWith('Many');
+
+    if (isToManyRelation) {
+      builder = builder.list;
+    }
+    // todo[v4]: How to handle polymorphic relation w/ entity response collection types?
+    //  -> Currently return raw polymorphic entities
+
+    const resolve = buildAssociationResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    // If there is no specific target specified, then use the GenericMorph type
+    if (isUndefined(target)) {
+      builder.field(attributeName, {
+        type: GENERIC_MORPH_TYPENAME,
+        resolve,
+      });
+    }
+
+    // If the target is an array of string, resolve the associated morph type and use it
+    else if (isArray(target) && target.every(isString)) {
+      const type = naming.getMorphRelationTypeName(contentType, attributeName);
+
+      builder.field(attributeName, { type, resolve });
+    }
+  };
+
+  /**
+   * Add a regular relational attribute to the type definition
+   * @param {TypeBuildersOptions} options
+   */
+  const addRegularRelationalAttribute = options => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    const extension = getGraphQLService('extension');
+
+    let { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+
+    if (extension.shadowCRUD(attribute.target).isDisabled()) {
+      return;
+    }
+
+    const isToManyRelation = attribute.relation.endsWith('Many');
+
+    const resolve = buildAssociationResolver({
+      contentTypeUID: contentType.uid,
+      attributeName,
+      strapi,
+    });
+
+    const targetContentType = strapi.getModel(attribute.target);
+
+    const type = isToManyRelation
+      ? naming.getRelationResponseCollectionName(targetContentType)
+      : naming.getEntityResponseName(targetContentType);
+
+    const args = isToManyRelation ? getContentTypeArgs(targetContentType) : undefined;
+
+    builder.field(attributeName, { type, resolve, args });
+  };
+
+  const isNotPrivate = contentType => attributeName => {
+    return !contentTypes.isPrivateAttribute(contentType, attributeName);
+  };
+
+  const isNotDisabled = contentType => attributeName => {
+    return extension
+      .shadowCRUD(contentType.uid)
+      .field(attributeName)
+      .hasOutputEnabled();
+  };
+
+  return {
+    /**
+     * Create a type definition for a given content type
+     * @param contentType - The content type used to created the definition
+     * @return {NexusObjectTypeDef}
+     */
+    buildTypeDefinition(contentType) {
+      const utils = getGraphQLService('utils');
+
+      const { getComponentName, getTypeName } = utils.naming;
+      const {
+        isStrapiScalar,
+        isComponent,
+        isDynamicZone,
+        isEnumeration,
+        isMedia,
+        isMorphRelation,
+        isRelation,
+      } = utils.attributes;
+
+      const { attributes, modelType, options = {} } = contentType;
+
+      const attributesKey = Object.keys(attributes);
+      const hasTimestamps = isArray(options.timestamps);
+
+      const name = (modelType === 'component' ? getComponentName : getTypeName).call(
+        null,
+        contentType
+      );
+
+      return objectType({
+        name,
+
+        definition(t) {
+          if (modelType === 'component' && isNotDisabled(contentType)('id')) {
+            t.nonNull.id('id');
+          }
+
+          // 1. Timestamps
+          // If the content type has timestamps enabled
+          // then we should add the corresponding attributes in the definition
+          if (hasTimestamps) {
+            const [createdAtKey, updatedAtKey] = contentType.options.timestamps;
+
+            t.nonNull.dateTime(createdAtKey);
+            t.nonNull.dateTime(updatedAtKey);
+          }
+
+          /** 2. Attributes
+           *
+           * Attributes can be of 7 different kind:
+           * - Scalar
+           * - Component
+           * - Dynamic Zone
+           * - Enum
+           * - Media
+           * - Polymorphic Relations
+           * - Regular Relations
+           *
+           * Here, we iterate over each non-private attribute
+           * and add it to the type definition based on its type
+           */
+          attributesKey
+            // Ignore private attributes
+            .filter(isNotPrivate(contentType))
+            // Ignore disabled fields (from extension service)
+            .filter(isNotDisabled(contentType))
+            // Add each attribute to the type definition
+            .forEach(attributeName => {
+              const attribute = attributes[attributeName];
+
+              // We create a copy of the builder (t) to apply custom
+              // rules only on the current attribute (eg: nonNull, list, ...)
+              let builder = t;
+
+              if (attribute.required) {
+                builder = builder.nonNull;
+              }
+
+              /**
+               * @type {TypeBuildersOptions}
+               */
+              const options = { builder, attributeName, attribute, contentType, context };
+
+              // Scalars
+              if (isStrapiScalar(attribute)) {
+                addScalarAttribute(options);
+              }
+
+              // Components
+              else if (isComponent(attribute)) {
+                addComponentAttribute(options);
+              }
+
+              // Dynamic Zones
+              else if (isDynamicZone(attribute)) {
+                addDynamicZoneAttribute(options);
+              }
+
+              // Enums
+              else if (isEnumeration(attribute)) {
+                addEnumAttribute(options);
+              }
+
+              // Media
+              else if (isMedia(attribute)) {
+                addMediaAttribute(options);
+              }
+
+              // Polymorphic Relations
+              else if (isMorphRelation(attribute)) {
+                addPolymorphicRelationalAttribute(options);
+              }
+
+              // Regular Relations
+              else if (isRelation(attribute) || isMedia(attribute)) {
+                addRegularRelationalAttribute(options);
+              }
+            });
+        },
+      });
+    },
+  };
+};

package/server/services/builders/utils.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { entries, mapValues, omit } = require('lodash/fp');
+const {
+  pagination: { withDefaultPagination },
+  contentTypes: { hasDraftAndPublish },
+} = require('@strapi/utils');
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  return {
+    /**
+     * Get every args for a given content type
+     * @param {object} contentType
+     * @param {object} options
+     * @param {boolean} options.multiple
+     * @return {object}
+     */
+    getContentTypeArgs(contentType, { multiple = true } = {}) {
+      const { naming } = getService('utils');
+      const { args } = getService('internals');
+
+      const { kind, modelType } = contentType;
+
+      // Components
+      if (modelType === 'component') {
+        return {
+          filters: naming.getFiltersInputTypeName(contentType),
+          pagination: args.PaginationArg,
+          sort: args.SortArg,
+        };
+      }
+
+      // Collection Types
+      else if (kind === 'collectionType') {
+        if (!multiple) {
+          return { id: 'ID' };
+        }
+
+        const params = {
+          filters: naming.getFiltersInputTypeName(contentType),
+          pagination: args.PaginationArg,
+          sort: args.SortArg,
+        };
+
+        if (hasDraftAndPublish(contentType)) {
+          Object.assign(params, { publicationState: args.PublicationStateArg });
+        }
+
+        return params;
+      }
+
+      // Single Types
+      else if (kind === 'singleType') {
+        const params = {};
+
+        if (hasDraftAndPublish(contentType)) {
+          Object.assign(params, { publicationState: args.PublicationStateArg });
+        }
+
+        return params;
+      }
+    },
+
+    /**
+     * Filter an object entries and keep only those whose value is a unique scalar attribute
+     * @param {object} attributes
+     * @return {Object<string, object>}
+     */
+    getUniqueScalarAttributes(attributes) {
+      const { isStrapiScalar } = getService('utils').attributes;
+
+      const uniqueAttributes = entries(attributes).filter(
+        ([, attribute]) => isStrapiScalar(attribute) && attribute.unique
+      );
+
+      return Object.fromEntries(uniqueAttributes);
+    },
+
+    /**
+     * Map each value from an attribute to a FiltersInput type name
+     * @param {object} attributes - The attributes object to transform
+     * @return {Object<string, string>}
+     */
+    scalarAttributesToFiltersMap: mapValues(attribute => {
+      const { mappers, naming } = getService('utils');
+
+      const gqlScalar = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+      return naming.getScalarFilterInputTypeName(gqlScalar);
+    }),
+
+    /**
+     * Apply basic transform to GQL args
+     */
+    transformArgs(args, { contentType, usePagination = false } = {}) {
+      const { mappers } = getService('utils');
+      const { pagination = {}, filters = {} } = args;
+
+      // Init
+      const newArgs = omit(['pagination', 'filters'], args);
+
+      // Pagination
+      if (usePagination) {
+        const defaultLimit = strapi.plugin('graphql').config('defaultLimit');
+        const maxLimit = strapi.plugin('graphql').config('maxLimit', -1);
+
+        Object.assign(
+          newArgs,
+          withDefaultPagination(pagination, {
+            maxLimit,
+            defaults: {
+              offset: { limit: defaultLimit },
+              page: { pageSize: defaultLimit },
+            },
+          })
+        );
+      }
+
+      // Filters
+      if (args.filters) {
+        Object.assign(newArgs, {
+          filters: mappers.graphQLFiltersToStrapiQuery(filters, contentType),
+        });
+      }
+
+      return newArgs;
+    },
+  };
+};

package/server/services/constants.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const PAGINATION_TYPE_NAME = 'Pagination';
+const PUBLICATION_STATE_TYPE_NAME = 'PublicationState';
+const ERROR_TYPE_NAME = 'Error';
+
+const RESPONSE_COLLECTION_META_TYPE_NAME = 'ResponseCollectionMeta';
+
+const GRAPHQL_SCALARS = [
+  'ID',
+  'Boolean',
+  'Int',
+  'String',
+  'Long',
+  'Float',
+  'JSON',
+  'Date',
+  'Time',
+  'DateTime',
+];
+
+const STRAPI_SCALARS = [
+  'boolean',
+  'integer',
+  'string',
+  'richtext',
+  'biginteger',
+  'float',
+  'decimal',
+  'json',
+  'date',
+  'time',
+  'datetime',
+  'timestamp',
+  'uid',
+  'email',
+  'password',
+  'text',
+];
+
+const SCALARS_ASSOCIATIONS = {
+  uid: 'String',
+  email: 'String',
+  password: 'String',
+  text: 'String',
+  boolean: 'Boolean',
+  integer: 'Int',
+  string: 'String',
+  richtext: 'String',
+  biginteger: 'Long',
+  float: 'Float',
+  decimal: 'Float',
+  json: 'JSON',
+  date: 'Date',
+  time: 'Time',
+  datetime: 'DateTime',
+  timestamp: 'DateTime',
+};
+
+const GENERIC_MORPH_TYPENAME = 'GenericMorph';
+
+const KINDS = {
+  type: 'type',
+  component: 'component',
+  dynamicZone: 'dynamic-zone',
+  enum: 'enum',
+  entity: 'entity',
+  entityResponse: 'entity-response',
+  entityResponseCollection: 'entity-response-collection',
+  relationResponseCollection: 'relation-response-collection',
+  query: 'query',
+  mutation: 'mutation',
+  input: 'input',
+  filtersInput: 'filters-input',
+  scalar: 'scalar',
+  morph: 'polymorphic',
+  internal: 'internal',
+};
+
+const allOperators = [
+  'and',
+  'or',
+  'not',
+
+  'eq',
+  'ne',
+
+  'startsWith',
+  'endsWith',
+
+  'contains',
+  'notContains',
+
+  'containsi',
+  'notContainsi',
+
+  'gt',
+  'gte',
+
+  'lt',
+  'lte',
+
+  'null',
+  'notNull',
+
+  'in',
+  'notIn',
+
+  'between',
+];
+
+const GRAPHQL_SCALAR_OPERATORS = {
+  // ID
+  ID: allOperators,
+  // Booleans
+  Boolean: allOperators,
+  // Strings
+  String: allOperators,
+  // Numbers
+  Int: allOperators,
+  Long: allOperators,
+  Float: allOperators,
+  // Dates
+  Date: allOperators,
+  Time: allOperators,
+  DateTime: allOperators,
+  // Others
+  JSON: allOperators,
+};
+
+const ERROR_CODES = {
+  emptyDynamicZone: 'dynamiczone.empty',
+};
+
+module.exports = () => ({
+  PAGINATION_TYPE_NAME,
+  RESPONSE_COLLECTION_META_TYPE_NAME,
+  PUBLICATION_STATE_TYPE_NAME,
+  GRAPHQL_SCALARS,
+  STRAPI_SCALARS,
+  GENERIC_MORPH_TYPENAME,
+  KINDS,
+  GRAPHQL_SCALAR_OPERATORS,
+  SCALARS_ASSOCIATIONS,
+  ERROR_CODES,
+  ERROR_TYPE_NAME,
+});