@strapi/plugin-graphql 4.0.0-next.6 → 4.0.0

package/server/services/internals/helpers/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const getEnabledScalars = require('./get-enabled-scalars');
+
+module.exports = context => ({
+  getEnabledScalars: getEnabledScalars(context),
+});

package/server/services/internals/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const args = require('./args');
+const scalars = require('./scalars');
+const types = require('./types');
+const helpers = require('./helpers');
+
+module.exports = context => ({
+  args: args(context),
+  scalars: scalars(context),
+  buildInternalTypes: types(context),
+  helpers: helpers(context),
+});

package/server/services/internals/scalars/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const GraphQLJSON = require('graphql-type-json');
+const GraphQLLong = require('graphql-type-long');
+const { GraphQLDateTime, GraphQLDate } = require('graphql-iso-date/dist');
+const { GraphQLUpload } = require('graphql-upload');
+const { asNexusMethod } = require('nexus');
+
+const TimeScalar = require('./time');
+
+module.exports = () => ({
+  JSON: asNexusMethod(GraphQLJSON, 'json'),
+  DateTime: asNexusMethod(GraphQLDateTime, 'dateTime'),
+  Time: asNexusMethod(TimeScalar, 'time'),
+  Date: asNexusMethod(GraphQLDate, 'date'),
+  Long: asNexusMethod(GraphQLLong, 'long'),
+  Upload: asNexusMethod(GraphQLUpload, 'upload'),
+});

package/server/services/internals/scalars/time.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { GraphQLScalarType } = require('graphql');
+const { Kind } = require('graphql');
+const { parseType } = require('@strapi/utils');
+const { ValidationError } = require('@strapi/utils').errors;
+
+/**
+ * A GraphQL scalar used to store Time (HH:mm:ss.SSS) values
+ * @type {GraphQLScalarType}
+ */
+const TimeScalar = new GraphQLScalarType({
+  name: 'Time',
+
+  description: 'A time string with format HH:mm:ss.SSS',
+
+  serialize(value) {
+    return parseType({ type: 'time', value });
+  },
+
+  parseValue(value) {
+    return parseType({ type: 'time', value });
+  },
+
+  parseLiteral(ast) {
+    if (ast.kind !== Kind.STRING) {
+      throw new ValidationError('Time cannot represent non string type');
+    }
+
+    const value = ast.value;
+
+    return parseType({ type: 'time', value });
+  },
+});
+
+module.exports = TimeScalar;

package/server/services/internals/types/error.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { objectType } = require('nexus');
+const { get } = require('lodash/fp');
+const { ValidationError } = require('@strapi/utils').errors;
+
+/**
+ * Build an Error object type
+ * @return {Object<string, NexusObjectTypeDef>}
+ */
+module.exports = ({ strapi }) => {
+  const { ERROR_CODES, ERROR_TYPE_NAME } = strapi.plugin('graphql').service('constants');
+
+  return objectType({
+    name: ERROR_TYPE_NAME,
+
+    definition(t) {
+      t.nonNull.string('code', {
+        resolve(parent) {
+          const code = get('code', parent);
+
+          const isValidPlaceholderCode = Object.values(ERROR_CODES).includes(code);
+          if (!isValidPlaceholderCode) {
+            throw new ValidationError(`"${code}" is not a valid code value`);
+          }
+
+          return code;
+        },
+      });
+
+      t.string('message');
+    },
+  });
+};

package/server/services/internals/types/filters.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { inputObjectType } = require('nexus');
+
+/**
+ * Build a map of filters type for every GraphQL scalars
+ * @return {Object<string, NexusInputTypeDef>}
+ */
+const buildScalarFilters = ({ strapi }) => {
+  const { naming, mappers } = strapi.plugin('graphql').service('utils');
+  const { helpers } = strapi.plugin('graphql').service('internals');
+
+  return helpers.getEnabledScalars().reduce((acc, type) => {
+    const operators = mappers.graphqlScalarToOperators(type);
+    const typeName = naming.getScalarFilterInputTypeName(type);
+
+    if (!operators || operators.length === 0) {
+      return acc;
+    }
+
+    return {
+      ...acc,
+
+      [typeName]: inputObjectType({
+        name: typeName,
+
+        definition(t) {
+          for (const operator of operators) {
+            operator.add(t, type);
+          }
+        },
+      }),
+    };
+  }, {});
+};
+
+module.exports = context => ({
+  scalars: buildScalarFilters(context),
+});

package/server/services/internals/types/index.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const pagination = require('./pagination');
+const buildResponseCollectionMeta = require('./response-collection-meta');
+const publicationState = require('./publication-state');
+const filters = require('./filters');
+const error = require('./error');
+
+module.exports = context => () => {
+  const { strapi } = context;
+
+  const { KINDS } = strapi.plugin('graphql').service('constants');
+
+  return {
+    [KINDS.internal]: {
+      error: error(context),
+      pagination: pagination(context),
+      responseCollectionMeta: buildResponseCollectionMeta(context),
+    },
+
+    [KINDS.enum]: {
+      publicationState: publicationState(context),
+    },
+
+    [KINDS.filtersInput]: {
+      ...filters(context),
+    },
+  };
+};

package/server/services/internals/types/pagination.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { objectType } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const { PAGINATION_TYPE_NAME } = strapi.plugin('graphql').service('constants');
+
+  return {
+    /**
+     * Type definition for a Pagination object
+     * @type {NexusObjectTypeDef}
+     */
+    Pagination: objectType({
+      name: PAGINATION_TYPE_NAME,
+
+      definition(t) {
+        t.nonNull.int('total');
+        t.nonNull.int('page');
+        t.nonNull.int('pageSize');
+        t.nonNull.int('pageCount');
+      },
+    }),
+  };
+};

package/server/services/internals/types/publication-state.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { enumType } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const { PUBLICATION_STATE_TYPE_NAME } = strapi.plugin('graphql').service('constants');
+
+  return {
+    /**
+     * An enum type definition representing a publication state
+     * @type {NexusEnumTypeDef}
+     */
+    PublicationState: enumType({
+      name: PUBLICATION_STATE_TYPE_NAME,
+
+      members: {
+        // Published only
+        LIVE: 'live',
+        // Published & draft
+        PREVIEW: 'preview',
+      },
+    }),
+  };
+};

package/server/services/internals/types/response-collection-meta.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { objectType } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const { RESPONSE_COLLECTION_META_TYPE_NAME, PAGINATION_TYPE_NAME } = strapi
+    .plugin('graphql')
+    .service('constants');
+
+  return {
+    /**
+     * A shared type definition used in EntitiesResponseCollection
+     * to have information about the collection as a whole
+     * @type {NexusObjectTypeDef}
+     */
+    ResponseCollectionMeta: objectType({
+      name: RESPONSE_COLLECTION_META_TYPE_NAME,
+
+      definition(t) {
+        t.nonNull.field('pagination', {
+          type: PAGINATION_TYPE_NAME,
+
+          async resolve(parent) {
+            const { args, resourceUID } = parent;
+            const { start, limit } = args;
+
+            const total = await strapi.entityService.count(resourceUID, args);
+            const pageSize = limit;
+            const pageCount = limit === 0 ? 0 : Math.ceil(total / limit);
+            const page = limit === 0 ? 1 : Math.floor(start / limit) + 1;
+
+            return { total, page, pageSize, pageCount };
+          },
+        });
+      },
+    }),
+  };
+};

package/server/services/type-registry.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const { isFunction } = require('lodash/fp');
+const { ApplicationError } = require('@strapi/utils').errors;
+
+/**
+ * @typedef RegisteredTypeDef
+ *
+ * @property {string} name
+ * @property {NexusAcceptedTypeDef} definition
+ * @property {object} config
+ */
+
+/**
+ * Create a new type registry
+ */
+const createTypeRegistry = () => {
+  const registry = new Map();
+
+  return {
+    /**
+     * Register a new type definition
+     * @param {string} name The name of the type
+     * @param {NexusAcceptedTypeDef} definition The Nexus definition for the type
+     * @param {object} [config] An optional config object with any metadata inside
+     */
+    register(name, definition, config = {}) {
+      if (registry.has(name)) {
+        throw new ApplicationError(`"${name}" has already been registered`);
+      }
+
+      registry.set(name, { name, definition, config });
+
+      return this;
+    },
+
+    /**
+     * Register many types definitions at once
+     * @param {[string, NexusAcceptedTypeDef][]} definitionsEntries
+     * @param {object | function} [config]
+     */
+    registerMany(definitionsEntries, config = {}) {
+      for (const [name, definition] of definitionsEntries) {
+        this.register(name, definition, isFunction(config) ? config(name, definition) : config);
+      }
+
+      return this;
+    },
+
+    /**
+     * Check if the given type name has already been added to the registry
+     * @param {string} name
+     * @return {boolean}
+     */
+    has(name) {
+      return registry.has(name);
+    },
+
+    /**
+     * Get the type definition for `name`
+     * @param {string} name - The name of the type
+     */
+    get(name) {
+      return registry.get(name);
+    },
+
+    /**
+     * Transform and return the registry as an object
+     * @return {Object<string, RegisteredTypeDef>}
+     */
+    toObject() {
+      return Object.fromEntries(registry.entries());
+    },
+
+    /**
+     * Return the name of every registered type
+     * @return {string[]}
+     */
+    get types() {
+      return Array.from(registry.keys());
+    },
+
+    /**
+     * Return all the registered definitions as an array
+     * @return {RegisteredTypeDef[]}
+     */
+    get definitions() {
+      return Array.from(registry.values());
+    },
+
+    /**
+     * Filter and return the types definitions that matches the given predicate
+     * @param {function(RegisteredTypeDef): boolean} predicate
+     * @return {RegisteredTypeDef[]}
+     */
+    where(predicate) {
+      return this.definitions.filter(predicate);
+    },
+  };
+};
+
+module.exports = () => ({
+  new: createTypeRegistry,
+});

package/server/services/utils/attributes.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { propEq } = require('lodash/fp');
+
+module.exports = ({ strapi }) => {
+  /**
+   * Check if the given attribute is a Strapi scalar
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isStrapiScalar = attribute => {
+    return strapi
+      .plugin('graphql')
+      .service('constants')
+      .STRAPI_SCALARS.includes(attribute.type);
+  };
+
+  /**
+   * Check if the given attribute is a GraphQL scalar
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isGraphQLScalar = attribute => {
+    return strapi
+      .plugin('graphql')
+      .service('constants')
+      .GRAPHQL_SCALARS.includes(attribute.type);
+  };
+
+  /**
+   * Check if the given attribute is a polymorphic relation
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isMorphRelation = attribute => {
+    return isRelation(attribute) && attribute.relation.includes('morph');
+  };
+
+  /**
+   * Check if the given attribute is a media
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isMedia = propEq('type', 'media');
+
+  /**
+   * Check if the given attribute is a relation
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isRelation = propEq('type', 'relation');
+
+  /**
+   * Check if the given attribute is an enum
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isEnumeration = propEq('type', 'enumeration');
+
+  /**
+   * Check if the given attribute is a component
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isComponent = propEq('type', 'component');
+
+  /**
+   * Check if the given attribute is a dynamic zone
+   * @param {object} attribute
+   * @return {boolean}
+   */
+  const isDynamicZone = propEq('type', 'dynamiczone');
+
+  return {
+    isStrapiScalar,
+    isGraphQLScalar,
+    isMorphRelation,
+    isMedia,
+    isRelation,
+    isEnumeration,
+    isComponent,
+    isDynamicZone,
+  };
+};

package/server/services/utils/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const mappers = require('./mappers');
+const attributes = require('./attributes');
+const naming = require('./naming');
+
+module.exports = context => ({
+  naming: naming(context),
+  attributes: attributes(context),
+  mappers: mappers(context),
+});

package/server/services/utils/mappers/entity-to-response-entity.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { map } = require('lodash/fp');
+
+const entityToResponseEntity = entity => ({ id: entity.id, attributes: entity });
+
+const entitiesToResponseEntities = map(entityToResponseEntity);
+
+module.exports = () => ({
+  entityToResponseEntity,
+  entitiesToResponseEntities,
+});

package/server/services/utils/mappers/graphql-filters-to-strapi-query.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const { has, propEq, isNil, isDate, isObject } = require('lodash/fp');
+
+// todo[v4]: Find a way to get that dynamically
+const virtualScalarAttributes = ['id'];
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const recursivelyReplaceScalarOperators = data => {
+    const { operators } = getService('builders').filters;
+
+    if (Array.isArray(data)) {
+      return data.map(recursivelyReplaceScalarOperators);
+    }
+
+    // Note: We need to make an exception for date since GraphQL
+    // automatically cast date strings to date instances in args
+    if (isDate(data) || !isObject(data)) {
+      return data;
+    }
+
+    const result = {};
+
+    for (const [key, value] of Object.entries(data)) {
+      const isOperator = !!operators[key];
+
+      const newKey = isOperator ? operators[key].strapiOperator : key;
+
+      result[newKey] = recursivelyReplaceScalarOperators(value);
+    }
+
+    return result;
+  };
+
+  return {
+    /**
+     * Transform one or many GraphQL filters object into a valid Strapi query
+     * @param {object | object[]} filters
+     * @param {object} contentType
+     * @return {object | object[]}
+     */
+    graphQLFiltersToStrapiQuery(filters, contentType = {}) {
+      const { isStrapiScalar, isMedia, isRelation } = getService('utils').attributes;
+      const { operators } = getService('builders').filters;
+
+      const ROOT_LEVEL_OPERATORS = [operators.and, operators.or, operators.not];
+
+      // Handle unwanted scenario where there is no filters defined
+      if (isNil(filters)) {
+        return {};
+      }
+
+      // If filters is a collection, then apply the transformation to every item of the list
+      if (Array.isArray(filters)) {
+        return filters.map(filtersItem =>
+          this.graphQLFiltersToStrapiQuery(filtersItem, contentType)
+        );
+      }
+
+      const resultMap = {};
+      const { attributes } = contentType;
+
+      const isAttribute = attributeName => {
+        return virtualScalarAttributes.includes(attributeName) || has(attributeName, attributes);
+      };
+
+      for (const [key, value] of Object.entries(filters)) {
+        // If the key is an attribute, update the value
+        if (isAttribute(key)) {
+          const attribute = attributes[key];
+
+          // If it's a scalar attribute
+          if (virtualScalarAttributes.includes(key) || isStrapiScalar(attribute)) {
+            // Replace (recursively) every GraphQL scalar operator with the associated Strapi operator
+            resultMap[key] = recursivelyReplaceScalarOperators(value);
+          }
+
+          // If it's a deep filter on a relation
+          else if (isRelation(attribute) || isMedia(attribute)) {
+            // Fetch the model from the relation
+            const relModel = strapi.getModel(attribute.target);
+
+            // Recursively apply the mapping to the value using the fetched model,
+            // and update the value within `resultMap`
+            resultMap[key] = this.graphQLFiltersToStrapiQuery(value, relModel);
+          }
+        }
+
+        // Handle the case where the key is not an attribute (operator, ...)
+        else {
+          const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(propEq('fieldName', key));
+
+          // If it's a root level operator (AND, NOT, OR, ...)
+          if (rootLevelOperator) {
+            const { strapiOperator } = rootLevelOperator;
+
+            // Transform the current value recursively and add it to the resultMap
+            // object using the strapiOperator equivalent of the GraphQL key
+            resultMap[strapiOperator] = this.graphQLFiltersToStrapiQuery(value, contentType);
+          }
+        }
+      }
+
+      return resultMap;
+    },
+  };
+};

package/server/services/utils/mappers/graphql-scalar-to-operators.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { get, map, mapValues } = require('lodash/fp');
+
+module.exports = ({ strapi }) => ({
+  graphqlScalarToOperators(graphqlScalar) {
+    const { GRAPHQL_SCALAR_OPERATORS } = strapi.plugin('graphql').service('constants');
+    const { operators } = strapi.plugin('graphql').service('builders').filters;
+
+    const associations = mapValues(
+      map(operatorName => operators[operatorName]),
+      GRAPHQL_SCALAR_OPERATORS
+    );
+
+    return get(graphqlScalar, associations);
+  },
+});

package/server/services/utils/mappers/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const strapiScalarToGraphQLScalar = require('./strapi-scalar-to-graphql-scalar');
+const graphQLFiltersToStrapiQuery = require('./graphql-filters-to-strapi-query');
+const graphqlScalarToOperators = require('./graphql-scalar-to-operators');
+const entityToResponseEntity = require('./entity-to-response-entity');
+
+module.exports = context => ({
+  ...strapiScalarToGraphQLScalar(context),
+  ...graphQLFiltersToStrapiQuery(context),
+  ...graphqlScalarToOperators(context),
+  ...entityToResponseEntity(context),
+});

package/server/services/utils/mappers/strapi-scalar-to-graphql-scalar.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { get, difference } = require('lodash/fp');
+const { ApplicationError } = require('@strapi/utils').errors;
+
+module.exports = ({ strapi }) => {
+  const { STRAPI_SCALARS, SCALARS_ASSOCIATIONS } = strapi.plugin('graphql').service('constants');
+
+  const missingStrapiScalars = difference(STRAPI_SCALARS, Object.keys(SCALARS_ASSOCIATIONS));
+
+  if (missingStrapiScalars.length > 0) {
+    throw new ApplicationError('Some Strapi scalars are not handled in the GraphQL scalars mapper');
+  }
+
+  return {
+    /**
+     * Used to transform a Strapi scalar type into its GraphQL equivalent
+     * @param {string} strapiScalar
+     * @return {NexusGenScalars}
+     */
+    strapiScalarToGraphQLScalar(strapiScalar) {
+      return get(strapiScalar, SCALARS_ASSOCIATIONS);
+    },
+  };
+};