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

package/services/type-builder.js

@@ -1,311 +0,0 @@
-'use strict';
-
-/**
- * Types.js service
- *
- * @description: A set of functions to make the schema easier to build.
- */
-
-const _ = require('lodash');
-const { GraphQLUpload } = require('graphql-upload');
-const graphql = require('graphql');
-const { GraphQLJSON } = require('graphql-type-json');
-const { GraphQLDate, GraphQLDateTime } = require('graphql-iso-date');
-const GraphQLLong = require('graphql-type-long');
-
-const Time = require('../types/time');
-const { toSingular, toInputName } = require('./naming');
-
-const isScalarAttribute = ({ type }) => type && !['component', 'dynamiczone'].includes(type);
-const isTypeAttributeEnabled = (model, attr) =>
-  _.get(strapi.plugins.graphql, `config._schema.graphql.type.${model.globalId}.${attr}`) !== false;
-
-module.exports = {
-  /**
-   * Convert Strapi type to GraphQL type.
-   * @param {Object} attribute Information about the attribute.
-   * @param {Object} attribute.definition Definition of the attribute.
-   * @param {String} attribute.modelName Name of the model which owns the attribute.
-   * @param {String} attribute.attributeName Name of the attribute.
-   * @return String
-   */
-
-  convertType({
-    attribute = {},
-    modelName = '',
-    attributeName = '',
-    rootType = 'query',
-    action = '',
-  }) {
-    // Type
-    if (isScalarAttribute(attribute)) {
-      let type = 'String';
-
-      switch (attribute.type) {
-        case 'boolean':
-          type = 'Boolean';
-          break;
-        case 'integer':
-          type = 'Int';
-          break;
-        case 'biginteger':
-          type = 'Long';
-          break;
-        case 'float':
-        case 'decimal':
-          type = 'Float';
-          break;
-        case 'json':
-          type = 'JSON';
-          break;
-        case 'date':
-          type = 'Date';
-          break;
-        case 'time':
-          type = 'Time';
-          break;
-        case 'datetime':
-        case 'timestamp':
-          type = 'DateTime';
-          break;
-        case 'enumeration':
-          type = this.convertEnumType(attribute, modelName, attributeName);
-          break;
-      }
-
-      if (attribute.required) {
-        if (rootType !== 'mutation' || (action !== 'update' && attribute.default === undefined)) {
-          type += '!';
-        }
-      }
-
-      return type;
-    }
-
-    if (attribute.type === 'component') {
-      const { required, repeatable, component } = attribute;
-
-      const globalId = strapi.components[component].globalId;
-
-      let typeName = required === true ? `${globalId}` : globalId;
-
-      if (rootType === 'mutation') {
-        typeName =
-          action === 'update'
-            ? `edit${_.upperFirst(toSingular(globalId))}Input`
-            : `${_.upperFirst(toSingular(globalId))}Input${required ? '!' : ''}`;
-      }
-
-      if (repeatable === true) {
-        return `[${typeName}]`;
-      }
-      return `${typeName}`;
-    }
-
-    if (attribute.type === 'dynamiczone') {
-      const { required } = attribute;
-
-      const unionName = `${modelName}${_.upperFirst(_.camelCase(attributeName))}DynamicZone`;
-
-      let typeName = unionName;
-
-      if (rootType === 'mutation') {
-        typeName = `${unionName}Input!`;
-      }
-
-      return `[${typeName}]${required ? '!' : ''}`;
-    }
-
-    const ref = attribute.target;
-
-    // Association
-    if (ref && ref !== '*') {
-      // Add bracket or not
-      const globalId = strapi.getModel(ref).globalId;
-      const plural = !_.isEmpty(attribute.collection);
-
-      if (plural) {
-        if (rootType === 'mutation') {
-          return '[ID]';
-        }
-
-        return `[${globalId}]`;
-      }
-
-      if (rootType === 'mutation') {
-        return 'ID';
-      }
-
-      return globalId;
-    }
-
-    if (rootType === 'mutation') {
-      return attribute.model ? 'ID' : '[ID]';
-    }
-
-    return attribute.model ? 'Morph' : '[Morph]';
-  },
-
-  /**
-   * Convert Strapi enumeration to GraphQL Enum.
-   * @param {Object} definition Definition of the attribute.
-   * @param {String} model Name of the model which owns the attribute.
-   * @param {String} field Name of the attribute.
-   * @return String
-   */
-
-  convertEnumType(definition, model, field) {
-    return definition.enumName
-      ? definition.enumName
-      : `ENUM_${model.toUpperCase()}_${field.toUpperCase()}`;
-  },
-
-  /**
-   * Add custom scalar type such as JSON.
-   *
-   * @return void
-   */
-
-  getScalars() {
-    return {
-      JSON: GraphQLJSON,
-      DateTime: GraphQLDateTime,
-      Time,
-      Date: GraphQLDate,
-      Long: GraphQLLong,
-      Upload: GraphQLUpload,
-    };
-  },
-
-  /**
-   * Add Union Type that contains the types defined by the user.
-   *
-   * @return string
-   */
-
-  addPolymorphicUnionType(definition) {
-    const types = graphql
-      .parse(definition)
-      .definitions.filter(def => def.kind === 'ObjectTypeDefinition' && def.name.value !== 'Query')
-      .map(def => def.name.value);
-
-    if (types.length > 0) {
-      return {
-        definition: `union Morph = ${types.join(' | ')}`,
-        resolvers: {
-          Morph: {
-            __resolveType(obj) {
-              return obj.kind || obj.__contentType || null;
-            },
-          },
-        },
-      };
-    }
-
-    return {
-      definition: '',
-      resolvers: {},
-    };
-  },
-
-  addInput() {
-    return `
-      input InputID { id: ID!}
-    `;
-  },
-
-  generateInputModel(model, name, { allowIds = false } = {}) {
-    const globalId = model.globalId;
-    const inputName = `${_.upperFirst(toSingular(name))}Input`;
-    const hasAllAttributesDisabled = Object.keys(model.attributes).every(
-      attr => !isTypeAttributeEnabled(model, attr)
-    );
-
-    if (_.isEmpty(model.attributes) || hasAllAttributesDisabled) {
-      return `
-      input ${inputName} {
-        _: String
-      }
-
-      input edit${inputName} {
-        ${allowIds ? 'id: ID' : '_: String'}
-      }
-     `;
-    }
-
-    const inputs = `
-      input ${inputName} {
-
-        ${Object.keys(model.attributes)
-          .filter(attributeName => isTypeAttributeEnabled(model, attributeName))
-          .map(attributeName => {
-            return `${attributeName}: ${this.convertType({
-              attribute: model.attributes[attributeName],
-              modelName: globalId,
-              attributeName,
-              rootType: 'mutation',
-            })}`;
-          })
-          .join('\n')}
-      }
-
-      input edit${inputName} {
-        ${allowIds ? 'id: ID' : ''}
-        ${Object.keys(model.attributes)
-          .filter(attributeName => isTypeAttributeEnabled(model, attributeName))
-          .map(attributeName => {
-            return `${attributeName}: ${this.convertType({
-              attribute: model.attributes[attributeName],
-              modelName: globalId,
-              attributeName,
-              rootType: 'mutation',
-              action: 'update',
-            })}`;
-          })
-          .join('\n')}
-      }
-    `;
-
-    return inputs;
-  },
-
-  generateInputPayloadArguments({ model, name, mutationName, action }) {
-    const singularName = toSingular(name);
-    const inputName = toInputName(name);
-
-    const { kind } = model;
-
-    switch (action) {
-      case 'create':
-        return `
-          input ${mutationName}Input { data: ${inputName} }
-          type ${mutationName}Payload { ${singularName}: ${model.globalId} }
-        `;
-      case 'update':
-        if (kind === 'singleType') {
-          return `
-          input ${mutationName}Input  { data: edit${inputName} }
-          type ${mutationName}Payload { ${singularName}: ${model.globalId} }
-        `;
-        }
-
-        return `
-          input ${mutationName}Input  { where: InputID, data: edit${inputName} }
-          type ${mutationName}Payload { ${singularName}: ${model.globalId} }
-        `;
-      case 'delete':
-        if (kind === 'singleType') {
-          return `
-          type ${mutationName}Payload { ${singularName}: ${model.globalId} }
-        `;
-        }
-
-        return `
-          input ${mutationName}Input  { where: InputID }
-          type ${mutationName}Payload { ${singularName}: ${model.globalId} }
-        `;
-      default:
-      // Nothing
-    }
-  },
-};

package/services/utils.js

@@ -1,200 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { QUERY_OPERATORS } = require('@strapi/utils');
-
-/**
- * @typedef {object} Schema
- * @property {object} resolvers
- * @property {object} mutation
- * @property {object} query
- * @property {string} definition
- */
-
-/**
- * Merges strapi graphql schema together
- * @param {Schema} object - destination object
- * @param  {Schema[]} sources - source objects to merge into the destination object
- * @returns {Schema}
- */
-const mergeSchemas = (object, ...sources) => {
-  sources.forEach(sub => {
-    if (_.isEmpty(sub)) return;
-    const { definition = '', query = {}, mutation = {}, resolvers = {} } = sub;
-
-    object.definition += '\n' + definition;
-    _.merge(object, {
-      query,
-      mutation,
-      resolvers,
-    });
-  });
-
-  return object;
-};
-
-/**
- * Returns an empty schema
- * @returns {Schema}
- */
-const createDefaultSchema = () => ({
-  definition: '',
-  query: {},
-  mutation: {},
-  resolvers: {},
-});
-
-const diffResolvers = (object, base) => {
-  let newObj = {};
-
-  Object.keys(object).forEach(type => {
-    Object.keys(object[type]).forEach(resolver => {
-      if (type === 'Query' || type === 'Mutation') {
-        if (!_.has(base, [type, resolver])) {
-          _.set(newObj, [type, resolver], _.get(object, [type, resolver]));
-        }
-      } else {
-        _.set(newObj, [type, resolver], _.get(object, [type, resolver]));
-      }
-    });
-  });
-
-  return newObj;
-};
-
-const convertToParams = params => {
-  return Object.keys(params).reduce((acc, current) => {
-    const key = current === 'id' ? 'id' : `_${current}`;
-    acc[key] = params[current];
-    return acc;
-  }, {});
-};
-
-const convertToQuery = params => {
-  const result = {};
-
-  _.forEach(params, (value, key) => {
-    if (QUERY_OPERATORS.includes(key)) {
-      result[key] = _.isArray(value) ? value.map(convertToQuery) : convertToQuery(value);
-    } else if (_.isPlainObject(value)) {
-      const flatObject = convertToQuery(value);
-      _.forEach(flatObject, (_value, _key) => {
-        result[`${key}.${_key}`] = _value;
-      });
-    } else {
-      result[key] = value;
-    }
-  });
-
-  return result;
-};
-
-const amountLimiting = (params = {}) => {
-  const { amountLimit } = strapi.plugins.graphql.config;
-
-  if (!amountLimit) return params;
-
-  if (_.isNil(params.limit) || params.limit === -1 || params.limit > amountLimit) {
-    params.limit = amountLimit;
-  } else if (params.limit < 0) {
-    params.limit = 0;
-  }
-
-  return params;
-};
-
-const nonRequired = type => type.replace('!', '');
-
-const actionExists = ({ resolver, resolverOf }) => {
-  if (isResolvablePath(resolverOf)) {
-    return true;
-  } else if (_.isFunction(resolver)) {
-    return true;
-  } else if (_.isString(resolver)) {
-    return _.isFunction(getActionFn(getActionDetails(resolver)));
-  } else {
-    throw new Error(
-      `Error building query. Expected \`resolver\` as string or a function, or \`resolverOf\` as a string. got ${{
-        resolver,
-        resolverOf,
-      }}`
-    );
-  }
-};
-
-const getAction = resolver => {
-  if (!_.isString(resolver)) {
-    throw new Error(`Error building query. Expected a string, got ${resolver}`);
-  }
-
-  const actionDetails = getActionDetails(resolver);
-  const actionFn = getActionFn(actionDetails);
-
-  if (!actionFn) {
-    throw new Error(
-      `[GraphQL] Cannot find action "${resolver}". Check your graphql configurations.`
-    );
-  }
-
-  return actionFn;
-};
-
-const getActionFn = details => {
-  const { controller, action, plugin, api } = details;
-
-  if (plugin) {
-    return _.get(strapi.plugins, [_.toLower(plugin), 'controllers', _.toLower(controller), action]);
-  }
-
-  return _.get(strapi.api, [_.toLower(api), 'controllers', _.toLower(controller), action]);
-};
-
-const getActionDetails = resolver => {
-  if (resolver.startsWith('plugins::')) {
-    const [, path] = resolver.split('::');
-    const [plugin, controller, action] = path.split('.');
-
-    return { plugin, controller, action };
-  }
-
-  if (resolver.startsWith('application::')) {
-    const [, path] = resolver.split('::');
-    const [api, controller, action] = path.split('.');
-
-    return { api, controller, action };
-  }
-
-  const args = resolver.split('.');
-
-  if (args.length === 3) {
-    const [api, controller, action] = args;
-    return { api, controller, action };
-  }
-
-  // if direct api access
-  if (args.length === 2) {
-    const [controller, action] = args;
-    return { api: controller, controller, action };
-  }
-
-  throw new Error(
-    `[GraphQL] Could not find action for resolver "${resolver}". Check your graphql configurations.`
-  );
-};
-
-const isResolvablePath = path => _.isString(path) && !_.isEmpty(path);
-
-module.exports = {
-  diffResolvers,
-  mergeSchemas,
-  createDefaultSchema,
-  convertToParams,
-  convertToQuery,
-  amountLimiting,
-  nonRequired,
-  actionExists,
-  getAction,
-  getActionDetails,
-  getActionFn,
-  isResolvablePath,
-};

package/types/dynamiczoneScalar.js

@@ -1,40 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { Kind, GraphQLScalarType, valueFromASTUntyped, GraphQLError } = require('graphql');
-
-module.exports = function DynamicZoneScalar({ name, attribute, globalId, components }) {
-  const parseData = value => {
-    const compo = Object.values(strapi.components).find(
-      compo => compo.globalId === value.__typename
-    );
-
-    if (!compo) {
-      throw new GraphQLError(
-        `Component not found. expected one of: ${components
-          .map(uid => strapi.components[uid].globalId)
-          .join(', ')}`
-      );
-    }
-
-    const finalValue = {
-      __component: compo.uid,
-      ..._.omit(value, ['__typename']),
-    };
-
-    return finalValue;
-  };
-
-  return new GraphQLScalarType({
-    name: name,
-    description: `Input type for dynamic zone ${attribute} of ${globalId}`,
-    serialize: value => value,
-    parseValue: value => parseData(value),
-    parseLiteral: (ast, variables) => {
-      if (ast.kind !== Kind.OBJECT) return undefined;
-
-      const value = valueFromASTUntyped(ast, variables);
-      return parseData(value);
-    },
-  });
-};

package/types/publication-state.js

@@ -1,16 +0,0 @@
-'use strict';
-
-module.exports = {
-  definition: `
-    enum PublicationState {
-      LIVE
-      PREVIEW
-    }
-  `,
-  resolver: {
-    PublicationState: {
-      LIVE: 'live',
-      PREVIEW: 'preview',
-    },
-  },
-};

package/types/time.js

@@ -1,26 +0,0 @@
-'use strict';
-
-const { parseType } = require('@strapi/utils');
-
-const { Kind, GraphQLScalarType } = require('graphql');
-
-const Time = 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 TypeError(`Time cannot represent non string type`);
-    }
-
-    const value = ast.value;
-    return parseType({ type: 'time', value });
-  },
-});
-
-module.exports = Time;