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

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,103 @@
+'use strict';
+
+const { isFunction } = require('lodash/fp');
+
+/**
+ * @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 Error(`"${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,107 @@
+'use strict';
+
+const { has, propEq, isNil } = 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);
+    }
+
+    if (typeof data !== 'object') {
+      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,24 @@
+'use strict';
+
+const { get, difference } = require('lodash/fp');
+
+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 Error('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);
+    },
+  };
+};