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

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,118 @@
+'use strict';
+
+const { inputObjectType, nonNull } = require('nexus');
+
+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]) =>
+            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) });
+            }
+          });
+        },
+      });
+    },
+  };
+};

package/server/services/builders/mutations/collection-type.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const { extendType, nonNull } = require('nexus');
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { transformArgs } = getService('builders').utils;
+  const { toEntityResponse } = getService('format').returnTypes;
+
+  const {
+    getCreateMutationTypeName,
+    getUpdateMutationTypeName,
+    getDeleteMutationTypeName,
+    getEntityResponseName,
+    getContentTypeInputName,
+  } = naming;
+
+  const addCreateMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const createMutationName = getCreateMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(createMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Create payload
+        data: nonNull(getContentTypeInputName(contentType)),
+      },
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        const { create } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const value = await create(parent, transformedArgs);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  const addUpdateMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const updateMutationName = getUpdateMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    // todo[v4]: Don't allow to filter using every unique attributes for now
+    // Only authorize filtering using unique scalar fields for updateOne queries
+    // const uniqueAttributes = getUniqueAttributesFiltersMap(attributes);
+
+    t.field(updateMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Query args
+        id: nonNull('ID'),
+        // todo[v4]: Don't allow to filter using every unique attributes for now
+        // ...uniqueAttributes,
+
+        // Update payload
+        data: nonNull(getContentTypeInputName(contentType)),
+      },
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        const { update } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const value = await update(parent, transformedArgs);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  const addDeleteMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const deleteMutationName = getDeleteMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    // todo[v4]: Don't allow to filter using every unique attributes for now
+    // Only authorize filtering using unique scalar fields for updateOne queries
+    // const uniqueAttributes = getUniqueAttributesFiltersMap(attributes);
+
+    t.field(deleteMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Query args
+        id: nonNull('ID'),
+        // todo[v4]: Don't allow to filter using every unique attributes for now
+        // ...uniqueAttributes,
+      },
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        const { delete: deleteResolver } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const value = await deleteResolver(parent, args);
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  return {
+    buildCollectionTypeMutations(contentType) {
+      const createMutationName = `Mutation.${getCreateMutationTypeName(contentType)}`;
+      const updateMutationName = `Mutation.${getUpdateMutationTypeName(contentType)}`;
+      const deleteMutationName = `Mutation.${getDeleteMutationTypeName(contentType)}`;
+
+      const extension = getService('extension');
+
+      const registerAuthConfig = (action, auth) => {
+        return extension.use({ resolversConfig: { [action]: { auth } } });
+      };
+
+      const isActionEnabled = action => {
+        return extension.shadowCRUD(contentType.uid).isActionEnabled(action);
+      };
+
+      const isCreateEnabled = isActionEnabled('create');
+      const isUpdateEnabled = isActionEnabled('update');
+      const isDeleteEnabled = isActionEnabled('delete');
+
+      if (isCreateEnabled) {
+        registerAuthConfig(createMutationName, { scope: [`${contentType.uid}.create`] });
+      }
+
+      if (isUpdateEnabled) {
+        registerAuthConfig(updateMutationName, { scope: [`${contentType.uid}.update`] });
+      }
+
+      if (isDeleteEnabled) {
+        registerAuthConfig(deleteMutationName, { scope: [`${contentType.uid}.delete`] });
+      }
+
+      return extendType({
+        type: 'Mutation',
+
+        definition(t) {
+          if (isCreateEnabled) {
+            addCreateMutation(t, contentType);
+          }
+
+          if (isUpdateEnabled) {
+            addUpdateMutation(t, contentType);
+          }
+
+          if (isDeleteEnabled) {
+            addDeleteMutation(t, contentType);
+          }
+        },
+      });
+    },
+  };
+};

package/server/services/builders/mutations/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const createCollectionTypeMutationsBuilder = require('./collection-type');
+const createSingleTypeMutationsBuilder = require('./single-type');
+
+module.exports = context => ({
+  ...createCollectionTypeMutationsBuilder(context),
+  ...createSingleTypeMutationsBuilder(context),
+});

package/server/services/builders/mutations/single-type.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const { extendType, nonNull } = require('nexus');
+const { omit, isNil } = require('lodash/fp');
+const { getNonWritableAttributes } = require('@strapi/utils').contentTypes;
+
+const sanitizeInput = (contentType, data) => omit(getNonWritableAttributes(contentType), data);
+
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { transformArgs } = getService('builders').utils;
+  const { toEntityResponse } = getService('format').returnTypes;
+
+  const {
+    getUpdateMutationTypeName,
+    getEntityResponseName,
+    getContentTypeInputName,
+    getDeleteMutationTypeName,
+  } = naming;
+
+  const addUpdateMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const updateMutationName = getUpdateMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(updateMutationName, {
+      type: responseTypeName,
+
+      args: {
+        // Update payload
+        data: nonNull(getContentTypeInputName(contentType)),
+      },
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        // Sanitize input data
+        Object.assign(transformedArgs, { data: sanitizeInput(contentType, transformedArgs.data) });
+
+        const { create, update } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const findParams = omit(['data', 'files'], transformedArgs);
+        const entity = await strapi.entityService.findMany(uid, { params: findParams });
+
+        // Create or update
+        const value = isNil(entity)
+          ? create(parent, transformedArgs)
+          : update(uid, { id: entity.id, data: transformedArgs.data });
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  const addDeleteMutation = (t, contentType) => {
+    const { uid } = contentType;
+
+    const deleteMutationName = getDeleteMutationTypeName(contentType);
+    const responseTypeName = getEntityResponseName(contentType);
+
+    t.field(deleteMutationName, {
+      type: responseTypeName,
+
+      args: {},
+
+      async resolve(parent, args) {
+        const transformedArgs = transformArgs(args, { contentType });
+
+        Object.assign(transformedArgs, { data: sanitizeInput(contentType, transformedArgs.data) });
+
+        const { delete: deleteResolver } = getService('builders')
+          .get('content-api')
+          .buildMutationsResolvers({ contentType });
+
+        const params = omit(['data', 'files'], transformedArgs);
+        const entity = await strapi.entityService.findMany(uid, { params });
+
+        if (!entity) {
+          throw new Error('Entity not found');
+        }
+
+        const value = await deleteResolver(parent, { id: entity.id, params });
+
+        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      },
+    });
+  };
+
+  return {
+    buildSingleTypeMutations(contentType) {
+      const updateMutationName = `Mutation.${getUpdateMutationTypeName(contentType)}`;
+      const deleteMutationName = `Mutation.${getDeleteMutationTypeName(contentType)}`;
+
+      const extension = getService('extension');
+
+      const registerAuthConfig = (action, auth) => {
+        return extension.use({ resolversConfig: { [action]: { auth } } });
+      };
+
+      const isActionEnabled = action => {
+        return extension.shadowCRUD(contentType.uid).isActionEnabled(action);
+      };
+
+      const isUpdateEnabled = isActionEnabled('update');
+      const isDeleteEnabled = isActionEnabled('delete');
+
+      if (isUpdateEnabled) {
+        registerAuthConfig(updateMutationName, { scope: [`${contentType.uid}.update`] });
+      }
+
+      if (isDeleteEnabled) {
+        registerAuthConfig(deleteMutationName, { scope: [`${contentType.uid}.delete`] });
+      }
+
+      return extendType({
+        type: 'Mutation',
+
+        definition(t) {
+          if (isUpdateEnabled) {
+            addUpdateMutation(t, contentType);
+          }
+
+          if (isDeleteEnabled) {
+            addDeleteMutation(t, contentType);
+          }
+        },
+      });
+    },
+  };
+};