@strapi/plugin-graphql 4.15.5 → 4.16.0

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

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

package/server/services/internals/index.js

@@ -1,13 +0,0 @@
-'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/date.js

@@ -1,22 +0,0 @@
-'use strict';
-
-const { GraphQLDate } = require('graphql-scalars');
-
-const parseAndCast =
-  (parseFn) =>
-  (...args) => {
-    const parsedValue = parseFn(...args);
-
-    if (parsedValue instanceof Date) {
-      return parsedValue.toISOString().split('T')[0];
-    }
-
-    return parsedValue;
-  };
-
-// GraphQLDate casts the date string to new Date, we want to keep it as a string so we cast it back to a string
-// see https://github.com/excitement-engineer/graphql-iso-date/issues/106
-GraphQLDate.parseValue = parseAndCast(GraphQLDate.parseValue);
-GraphQLDate.parseLiteral = parseAndCast(GraphQLDate.parseLiteral);
-
-module.exports = GraphQLDate;

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

@@ -1,17 +0,0 @@
-'use strict';
-
-const { GraphQLDateTime, GraphQLLong, GraphQLJSON } = require('graphql-scalars');
-const { GraphQLUpload } = require('graphql-upload');
-const { asNexusMethod } = require('nexus');
-
-const TimeScalar = require('./time');
-const GraphQLDate = require('./date');
-
-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

@@ -1,36 +0,0 @@
-'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;
-
-    return parseType({ type: 'time', value });
-  },
-});
-
-module.exports = TimeScalar;

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

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

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

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

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

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

@@ -1,46 +0,0 @@
-'use strict';
-
-const { objectType } = require('nexus');
-const { sanitize, validate } = require('@strapi/utils');
-
-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, _childArgs, ctx) {
-            const { args, resourceUID } = parent;
-            const { start, limit } = args;
-            const safeLimit = Math.max(limit, 1);
-            const contentType = strapi.getModel(resourceUID);
-            await validate.contentAPI.query(args, contentType, {
-              auth: ctx?.state?.auth,
-            });
-            const sanitizedQuery = await sanitize.contentAPI.query(args, contentType, {
-              auth: ctx?.state?.auth,
-            });
-            const total = await strapi.entityService.count(resourceUID, sanitizedQuery);
-            const pageSize = limit === -1 ? total - start : safeLimit;
-            const pageCount = limit === -1 ? safeLimit : Math.ceil(total / safeLimit);
-            const page = limit === -1 ? safeLimit : Math.floor(start / safeLimit) + 1;
-
-            return { total, page, pageSize, pageCount };
-          },
-        });
-      },
-    }),
-  };
-};

package/server/services/type-registry.js

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

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

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

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

@@ -1,119 +0,0 @@
-'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, isComponent } = 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);
-          }
-
-          // If it's a deep filter on a component
-          else if (isComponent(attribute)) {
-            // Fetch the model from the component attribute
-            const componentModel = strapi.getModel(attribute.component);
-
-            // Recursively apply the mapping to the value using the fetched model,
-            // and update the value within `resultMap`
-            resultMap[key] = this.graphQLFiltersToStrapiQuery(value, componentModel);
-          }
-        }
-
-        // 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

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

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

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