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

package/server/services/builders/filters/operators/ends-with.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const ENDS_WITH_FIELD_NAME = 'endsWith';
+
+module.exports = () => ({
+  fieldName: ENDS_WITH_FIELD_NAME,
+
+  strapiOperator: '$endsWith',
+
+  add(t, type) {
+    t.field(ENDS_WITH_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/eq.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { ValidationError } = require('@strapi/utils').errors;
+
+const EQ_FIELD_NAME = 'eq';
+
+module.exports = ({ strapi }) => ({
+  fieldName: EQ_FIELD_NAME,
+
+  strapiOperator: '$eq',
+
+  add(t, type) {
+    const { GRAPHQL_SCALARS } = strapi.plugin('graphql').service('constants');
+
+    if (!GRAPHQL_SCALARS.includes(type)) {
+      throw new ValidationError(
+        `Can't use "${EQ_FIELD_NAME}" operator. "${type}" is not a valid scalar`
+      );
+    }
+
+    t.field(EQ_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/gt.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const GT_FIELD_NAME = 'gt';
+
+module.exports = () => ({
+  fieldName: GT_FIELD_NAME,
+
+  strapiOperator: '$gt',
+
+  add(t, type) {
+    t.field(GT_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/gte.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const GTE_FIELD_NAME = 'gte';
+
+module.exports = () => ({
+  fieldName: GTE_FIELD_NAME,
+
+  strapiOperator: '$gte',
+
+  add(t, type) {
+    t.field(GTE_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/in.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { list } = require('nexus');
+
+const IN_FIELD_NAME = 'in';
+
+module.exports = () => ({
+  fieldName: IN_FIELD_NAME,
+
+  strapiOperator: '$in',
+
+  add(t, type) {
+    t.field(IN_FIELD_NAME, { type: list(type) });
+  },
+});

package/server/services/builders/filters/operators/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { mapValues } = require('lodash/fp');
+
+const operators = {
+  and: require('./and'),
+  or: require('./or'),
+  not: require('./not'),
+
+  eq: require('./eq'),
+  ne: require('./ne'),
+
+  startsWith: require('./starts-with'),
+  endsWith: require('./ends-with'),
+
+  contains: require('./contains'),
+  notContains: require('./not-contains'),
+
+  containsi: require('./containsi'),
+  notContainsi: require('./not-containsi'),
+
+  gt: require('./gt'),
+  gte: require('./gte'),
+
+  lt: require('./lt'),
+  lte: require('./lte'),
+
+  null: require('./null'),
+  notNull: require('./not-null'),
+
+  in: require('./in'),
+  notIn: require('./not-in'),
+
+  between: require('./between'),
+};
+
+// Instantiate every operator with the Strapi instance
+module.exports = context => mapValues(opCtor => opCtor(context), operators);

package/server/services/builders/filters/operators/lt.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const LT_FIELD_NAME = 'lt';
+
+module.exports = () => ({
+  fieldName: LT_FIELD_NAME,
+
+  strapiOperator: '$lt',
+
+  add(t, type) {
+    t.field(LT_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/lte.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const LTE_FIELD_NAME = 'lte';
+
+module.exports = () => ({
+  fieldName: LTE_FIELD_NAME,
+
+  strapiOperator: '$lte',
+
+  add(t, type) {
+    t.field(LTE_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/ne.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const NE_FIELD_NAME = 'ne';
+
+module.exports = () => ({
+  fieldName: NE_FIELD_NAME,
+
+  strapiOperator: '$ne',
+
+  add(t, type) {
+    t.field(NE_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/not-contains.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const NOT_CONTAINS_FIELD_NAME = 'notContains';
+
+module.exports = () => ({
+  fieldName: NOT_CONTAINS_FIELD_NAME,
+
+  strapiOperator: '$notContains',
+
+  add(t, type) {
+    t.field(NOT_CONTAINS_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/not-containsi.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const NOT_CONTAINSI_FIELD_NAME = 'notContainsi';
+
+module.exports = () => ({
+  fieldName: NOT_CONTAINSI_FIELD_NAME,
+
+  strapiOperator: '$notContainsi',
+
+  add(t, type) {
+    t.field(NOT_CONTAINSI_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/filters/operators/not-in.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { list } = require('nexus');
+
+const NOT_IN_FIELD_NAME = 'notIn';
+
+module.exports = () => ({
+  fieldName: NOT_IN_FIELD_NAME,
+
+  strapiOperator: '$notIn',
+
+  add(t, type) {
+    t.field(NOT_IN_FIELD_NAME, { type: list(type) });
+  },
+});

package/server/services/builders/filters/operators/not-null.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const NOT_NULL_FIELD_NAME = 'notNull';
+
+module.exports = () => ({
+  fieldName: NOT_NULL_FIELD_NAME,
+
+  strapiOperator: '$notNull',
+
+  add(t) {
+    t.boolean(NOT_NULL_FIELD_NAME);
+  },
+});

package/server/services/builders/filters/operators/not.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const NOT_FIELD_NAME = 'not';
+
+module.exports = ({ strapi }) => ({
+  fieldName: NOT_FIELD_NAME,
+
+  strapiOperator: '$not',
+
+  add(t, type) {
+    const { naming, attributes } = strapi.plugin('graphql').service('utils');
+
+    if (attributes.isGraphQLScalar({ type })) {
+      t.field(NOT_FIELD_NAME, { type: naming.getScalarFilterInputTypeName(type) });
+    } else {
+      t.field(NOT_FIELD_NAME, { type });
+    }
+  },
+});

package/server/services/builders/filters/operators/null.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const NULL_FIELD_NAME = 'null';
+
+module.exports = () => ({
+  fieldName: NULL_FIELD_NAME,
+
+  strapiOperator: '$null',
+
+  add(t) {
+    t.boolean(NULL_FIELD_NAME);
+  },
+});

package/server/services/builders/filters/operators/or.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { list } = require('nexus');
+
+const OR_FIELD_NAME = 'or';
+
+module.exports = () => ({
+  fieldName: OR_FIELD_NAME,
+
+  strapiOperator: '$or',
+
+  add(t, type) {
+    t.field(OR_FIELD_NAME, { type: list(type) });
+  },
+});

package/server/services/builders/filters/operators/starts-with.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const STARTS_WITH_FIELD_NAME = 'startsWith';
+
+module.exports = () => ({
+  fieldName: STARTS_WITH_FIELD_NAME,
+
+  strapiOperator: '$startsWith',
+
+  add(t, type) {
+    t.field(STARTS_WITH_FIELD_NAME, { type });
+  },
+});

package/server/services/builders/generic-morph.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { unionType } = require('nexus');
+const { prop } = require('lodash/fp');
+
+module.exports = ({ strapi, registry }) => {
+  const { naming } = strapi.plugin('graphql').service('utils');
+  const { KINDS, GENERIC_MORPH_TYPENAME } = strapi.plugin('graphql').service('constants');
+
+  return {
+    buildGenericMorphDefinition() {
+      return unionType({
+        name: GENERIC_MORPH_TYPENAME,
+
+        resolveType(obj) {
+          const contentType = strapi.getModel(obj.__type);
+
+          if (!contentType) {
+            return null;
+          }
+
+          if (contentType.modelType === 'component') {
+            return naming.getComponentName(contentType);
+          }
+
+          return naming.getTypeName(contentType);
+        },
+
+        definition(t) {
+          const members = registry
+            // Resolve every content-type or component
+            .where(({ config }) => [KINDS.type, KINDS.component].includes(config.kind))
+            // Only keep their name (the type's id)
+            .map(prop('name'));
+
+          t.members(...members);
+        },
+      });
+    },
+  };
+};

package/server/services/builders/index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const { merge, map, pipe, reduce } = require('lodash/fp');
+
+// Builders Factories
+
+const enums = require('./enums');
+const dynamicZone = require('./dynamic-zones');
+const entity = require('./entity');
+const entityMeta = require('./entity-meta');
+const type = require('./type');
+const response = require('./response');
+const responseCollection = require('./response-collection');
+const relationResponseCollection = require('./relation-response-collection');
+const queries = require('./queries');
+const mutations = require('./mutations');
+const filters = require('./filters');
+const inputs = require('./input');
+const genericMorph = require('./generic-morph');
+const resolvers = require('./resolvers');
+
+// Misc
+
+const operators = require('./filters/operators');
+const utils = require('./utils');
+
+const buildersFactories = [
+  enums,
+  dynamicZone,
+  entity,
+  entityMeta,
+  type,
+  response,
+  responseCollection,
+  relationResponseCollection,
+  queries,
+  mutations,
+  filters,
+  inputs,
+  genericMorph,
+  resolvers,
+];
+
+module.exports = ({ strapi }) => {
+  const buildersMap = new Map();
+
+  return {
+    /**
+     * Instantiate every builder with a strapi instance & a type registry
+     * @param {string} name
+     * @param {object} registry
+     */
+    new(name, registry) {
+      const context = { strapi, registry };
+
+      const builders = pipe(
+        // Create a new instance of every builders
+        map(factory => factory(context)),
+        // Merge every builder into the same object
+        reduce(merge, {})
+      ).call(null, buildersFactories);
+
+      buildersMap.set(name, builders);
+
+      return builders;
+    },
+
+    /**
+     * Delete a set of builders instances from
+     * the builders map for a given name
+     * @param {string} name
+     */
+    delete(name) {
+      buildersMap.delete(name);
+    },
+
+    /**
+     * Retrieve a set of builders instances from
+     * the builders map for a given name
+     * @param {string} name
+     */
+    get(name) {
+      return buildersMap.get(name);
+    },
+
+    filters: {
+      operators: operators({ strapi }),
+    },
+
+    utils: utils({ strapi }),
+  };
+};

package/server/services/builders/input.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const { inputObjectType, nonNull } = require('nexus');
+const {
+  contentTypes: { isWritableAttribute },
+} = require('@strapi/utils');
+
+module.exports = context => {
+  const { strapi } = context;
+
+  const { naming, mappers, attributes } = strapi.plugin('graphql').service('utils');
+  const extension = strapi.plugin('graphql').service('extension');
+
+  const {
+    getComponentInputName,
+    getContentTypeInputName,
+    getEnumName,
+    getDynamicZoneInputName,
+  } = naming;
+
+  const {
+    isStrapiScalar,
+    isRelation,
+    isMorphRelation,
+    isMedia,
+    isEnumeration,
+    isComponent,
+    isDynamicZone,
+  } = attributes;
+
+  return {
+    buildInputType(contentType) {
+      const { attributes, modelType } = contentType;
+
+      const name = (modelType === 'component'
+        ? getComponentInputName
+        : getContentTypeInputName
+      ).call(null, contentType);
+
+      return inputObjectType({
+        name,
+
+        definition(t) {
+          const isFieldEnabled = fieldName => {
+            return extension
+              .shadowCRUD(contentType.uid)
+              .field(fieldName)
+              .hasInputEnabled();
+          };
+
+          const validAttributes = Object.entries(attributes).filter(([attributeName]) => {
+            return isWritableAttribute(contentType, attributeName) && isFieldEnabled(attributeName);
+          });
+
+          // Add the ID for the component to enable inplace updates
+          if (modelType === 'component' && isFieldEnabled('id')) {
+            t.id('id');
+          }
+
+          validAttributes.forEach(([attributeName, attribute]) => {
+            // Scalars
+            if (isStrapiScalar(attribute)) {
+              const gqlScalar = mappers.strapiScalarToGraphQLScalar(attribute.type);
+
+              t.field(attributeName, { type: gqlScalar });
+            }
+
+            // Media
+            else if (isMedia(attribute)) {
+              const isMultiple = attribute.multiple === true;
+
+              if (extension.shadowCRUD('plugin::upload.file').isDisabled()) {
+                return;
+              }
+
+              isMultiple ? t.list.id(attributeName) : t.id(attributeName);
+            }
+
+            // Regular Relations (ignore polymorphic relations)
+            else if (isRelation(attribute) && !isMorphRelation(attribute)) {
+              if (extension.shadowCRUD(attribute.target).isDisabled()) {
+                return;
+              }
+
+              const isToManyRelation = attribute.relation.endsWith('Many');
+
+              isToManyRelation ? t.list.id(attributeName) : t.id(attributeName);
+            }
+
+            // Enums
+            else if (isEnumeration(attribute)) {
+              const enumTypeName = getEnumName(contentType, attributeName);
+
+              t.field(attributeName, { type: enumTypeName });
+            }
+
+            // Components
+            else if (isComponent(attribute)) {
+              const isRepeatable = attribute.repeatable === true;
+              const component = strapi.components[attribute.component];
+              const componentInputType = getComponentInputName(component);
+
+              if (isRepeatable) {
+                t.list.field(attributeName, { type: componentInputType });
+              } else {
+                t.field(attributeName, { type: componentInputType });
+              }
+            }
+
+            // Dynamic Zones
+            else if (isDynamicZone(attribute)) {
+              const dzInputName = getDynamicZoneInputName(contentType, attributeName);
+
+              t.list.field(attributeName, { type: nonNull(dzInputName) });
+            }
+          });
+        },
+      });
+    },
+  };
+};