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

package/server/services/content-api/index.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const {
+  mergeSchemas,
+  makeExecutableSchema,
+  addResolversToSchema,
+} = require('@graphql-tools/schema');
+const { makeSchema } = require('nexus');
+const { pipe, prop, startsWith } = require('lodash/fp');
+
+const { wrapResolvers } = require('./wrap-resolvers');
+const {
+  registerSingleType,
+  registerCollectionType,
+  registerComponent,
+  registerScalars,
+  registerInternals,
+  registerPolymorphicContentType,
+  contentType: {
+    registerEnumsDefinition,
+    registerInputsDefinition,
+    registerFiltersDefinition,
+    registerDynamicZonesDefinition,
+  },
+} = require('./register-functions');
+
+module.exports = ({ strapi }) => {
+  const { service: getGraphQLService } = strapi.plugin('graphql');
+  const { config } = strapi.plugin('graphql');
+
+  const { KINDS, GENERIC_MORPH_TYPENAME } = getGraphQLService('constants');
+
+  // Type Registry
+  let registry;
+  // Builders Instances
+  let builders;
+
+  const buildSchema = () => {
+    const extensionService = getGraphQLService('extension');
+
+    const isShadowCRUDEnabled = !!config('shadowCRUD', true);
+
+    // Create a new empty type registry
+    registry = getGraphQLService('type-registry').new();
+
+    // Reset the builders instances associated to the
+    // content-api, and link the new type registry
+    builders = getGraphQLService('builders').new('content-api', registry);
+
+    registerScalars({ registry, strapi });
+    registerInternals({ registry, strapi });
+
+    if (isShadowCRUDEnabled) {
+      shadowCRUD();
+    }
+
+    // Generate the extension configuration for the content API
+    const extension = extensionService.generate({ typeRegistry: registry });
+
+    return pipe(
+      // Build a collection of schema based on the
+      // type registry & the extension configuration
+      buildSchemas,
+      // Merge every created schema into a single one
+      schemas => mergeSchemas({ schemas }),
+      // Add the extension's resolvers to the final schema
+      schema => addResolversToSchema(schema, extension.resolvers),
+      // Wrap resolvers if needed (auth, middlewares, policies...) as configured in the extension
+      schema => wrapResolvers({ schema, strapi, extension })
+    )({ registry, extension });
+  };
+
+  const buildSchemas = ({ registry, extension }) => {
+    const { types, plugins, typeDefs = [] } = extension;
+
+    // Create a new Nexus schema (shadow CRUD) & add it to the schemas collection
+    const nexusSchema = makeSchema({
+      types: [
+        // Add the auto-generated Nexus types (shadow CRUD)
+        registry.definitions,
+        // Add every Nexus type registered using the extension service
+        types,
+      ],
+
+      plugins: [
+        // Add every plugin registered using the extension service
+        ...plugins,
+      ],
+    });
+
+    // Build schemas based on SDL type definitions (defined in the extension)
+    const sdlSchemas = typeDefs.map(sdl => makeExecutableSchema({ typeDefs: sdl }));
+
+    return [nexusSchema, ...sdlSchemas];
+  };
+
+  const shadowCRUD = () => {
+    const extensionService = getGraphQLService('extension');
+
+    // Get every content type & component defined in Strapi
+    const contentTypes = [
+      ...Object.values(strapi.components),
+      ...Object.values(strapi.contentTypes),
+    ];
+
+    // Disable Shadow CRUD for admin content types
+    contentTypes
+      .map(prop('uid'))
+      .filter(startsWith('admin::'))
+      .forEach(uid => extensionService.shadowCRUD(uid).disable());
+
+    const contentTypesWithShadowCRUD = contentTypes.filter(ct =>
+      extensionService.shadowCRUD(ct.uid).isEnabled()
+    );
+
+    // Generate and register definitions for every content type
+    registerAPITypes(contentTypesWithShadowCRUD);
+
+    // Generate and register polymorphic types' definitions
+    registerMorphTypes(contentTypesWithShadowCRUD);
+  };
+
+  /**
+   * Register needed GraphQL types for every content type
+   * @param {object[]} contentTypes
+   */
+  const registerAPITypes = contentTypes => {
+    for (const contentType of contentTypes) {
+      const { kind, modelType } = contentType;
+
+      const registerOptions = { registry, strapi, builders };
+
+      // Generate various types associated to the content type
+      // (enums, dynamic-zones, filters, inputs...)
+      registerEnumsDefinition(contentType, registerOptions);
+      registerDynamicZonesDefinition(contentType, registerOptions);
+      registerFiltersDefinition(contentType, registerOptions);
+      registerInputsDefinition(contentType, registerOptions);
+
+      // Generate & register component's definition
+      if (modelType === 'component') {
+        registerComponent(contentType, registerOptions);
+      }
+
+      // Generate & register single type's definition
+      else if (kind === 'singleType') {
+        registerSingleType(contentType, registerOptions);
+      }
+
+      // Generate & register collection type's definition
+      else if (kind === 'collectionType') {
+        registerCollectionType(contentType, registerOptions);
+      }
+    }
+  };
+
+  const registerMorphTypes = contentTypes => {
+    // Create & register a union type that includes every type or component registered
+    const genericMorphType = builders.buildGenericMorphDefinition();
+    registry.register(GENERIC_MORPH_TYPENAME, genericMorphType, { kind: KINDS.morph });
+
+    for (const contentType of contentTypes) {
+      registerPolymorphicContentType(contentType, { registry, strapi });
+    }
+  };
+
+  return { buildSchema };
+};

package/server/services/content-api/policy.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { getOr } = require('lodash/fp');
+const { policy: policyUtils } = require('@strapi/utils');
+
+const createPoliciesMiddleware = (resolverConfig, { strapi }) => {
+  return async (resolve, ...rest) => {
+    const resolverPolicies = getOr([], 'policies', resolverConfig);
+
+    // Transform every policy into a unique format
+    const policies = resolverPolicies.map(policy => policyUtils.get(policy));
+
+    // Create a graphql policy context
+    const context = createGraphQLPolicyContext(...rest);
+
+    // Run policies & throw an error if one of them fails
+    for (const policy of policies) {
+      const result = await policy({ context, strapi });
+
+      if (!result) {
+        throw new Error('Policies failed');
+      }
+    }
+
+    return resolve(...rest);
+  };
+};
+
+const createGraphQLPolicyContext = (parent, args, context, info) => {
+  return policyUtils.createPolicyContext('graphql', {
+    get parent() {
+      return parent;
+    },
+
+    get args() {
+      return args;
+    },
+
+    get context() {
+      return context;
+    },
+
+    get info() {
+      return info;
+    },
+
+    get state() {
+      return this.context.state;
+    },
+
+    get http() {
+      return this.context.koaContext;
+    },
+  });
+};
+
+module.exports = {
+  createPoliciesMiddleware,
+};

package/server/services/content-api/register-functions/collection-type.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const registerCollectionType = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { KINDS } = getService('constants');
+
+  const extension = getService('extension');
+
+  // Types name (as string)
+  const types = {
+    base: naming.getTypeName(contentType),
+    entity: naming.getEntityName(contentType),
+    response: naming.getEntityResponseName(contentType),
+    responseCollection: naming.getEntityResponseCollectionName(contentType),
+    relationResponseCollection: naming.getRelationResponseCollectionName(contentType),
+    queries: naming.getEntityQueriesTypeName(contentType),
+    mutations: naming.getEntityMutationsTypeName(contentType),
+  };
+
+  const getConfig = kind => ({ kind, contentType });
+
+  // Type definition
+  registry.register(types.base, builders.buildTypeDefinition(contentType), getConfig(KINDS.type));
+
+  // Higher level entity definition
+  registry.register(
+    types.entity,
+    builders.buildEntityDefinition(contentType),
+    getConfig(KINDS.entity)
+  );
+
+  // Responses definition
+  registry.register(
+    types.response,
+    builders.buildResponseDefinition(contentType),
+    getConfig(KINDS.entityResponse)
+  );
+
+  registry.register(
+    types.responseCollection,
+    builders.buildResponseCollectionDefinition(contentType),
+    getConfig(KINDS.entityResponseCollection)
+  );
+
+  registry.register(
+    types.relationResponseCollection,
+    builders.buildRelationResponseCollectionDefinition(contentType),
+    getConfig(KINDS.relationResponseCollection)
+  );
+
+  if (extension.shadowCRUD(contentType.uid).areQueriesEnabled()) {
+    // Query extensions
+    registry.register(
+      types.queries,
+      builders.buildCollectionTypeQueries(contentType),
+      getConfig(KINDS.query)
+    );
+  }
+
+  if (extension.shadowCRUD(contentType.uid).areMutationsEnabled()) {
+    // Mutation extensions
+    registry.register(
+      types.mutations,
+      builders.buildCollectionTypeMutations(contentType),
+      getConfig(KINDS.mutation)
+    );
+  }
+};
+
+module.exports = { registerCollectionType };

package/server/services/content-api/register-functions/component.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const registerComponent = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { getComponentName } = getService('utils').naming;
+  const { KINDS } = getService('constants');
+
+  const name = getComponentName(contentType);
+  const definition = builders.buildTypeDefinition(contentType);
+
+  registry.register(name, definition, { kind: KINDS.component, contentType });
+};
+
+module.exports = { registerComponent };

package/server/services/content-api/register-functions/content-type/dynamic-zones.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const registerDynamicZonesDefinition = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const {
+    naming,
+    attributes: { isDynamicZone },
+  } = getService('utils');
+  const { KINDS } = getService('constants');
+
+  const { attributes } = contentType;
+
+  const dynamicZoneAttributes = Object.keys(attributes).filter(attributeName =>
+    isDynamicZone(attributes[attributeName])
+  );
+
+  for (const attributeName of dynamicZoneAttributes) {
+    const attribute = attributes[attributeName];
+    const dzName = naming.getDynamicZoneName(contentType, attributeName);
+    const dzInputName = naming.getDynamicZoneInputName(contentType, attributeName);
+
+    const [type, input] = builders.buildDynamicZoneDefinition(attribute, dzName, dzInputName);
+
+    const baseConfig = {
+      contentType,
+      attributeName,
+      attribute,
+    };
+
+    registry.register(dzName, type, { kind: KINDS.dynamicZone, ...baseConfig });
+    registry.register(dzInputName, input, { kind: KINDS.input, ...baseConfig });
+  }
+};
+
+module.exports = { registerDynamicZonesDefinition };

package/server/services/content-api/register-functions/content-type/enums.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const registerEnumsDefinition = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const {
+    naming,
+    attributes: { isEnumeration },
+  } = getService('utils');
+  const { KINDS } = getService('constants');
+
+  const { attributes } = contentType;
+
+  const enumAttributes = Object.keys(attributes).filter(attributeName =>
+    isEnumeration(attributes[attributeName])
+  );
+
+  for (const attributeName of enumAttributes) {
+    const attribute = attributes[attributeName];
+
+    const enumName = naming.getEnumName(contentType, attributeName);
+    const enumDefinition = builders.buildEnumTypeDefinition(attribute, enumName);
+
+    registry.register(enumName, enumDefinition, {
+      kind: KINDS.enum,
+      contentType,
+      attributeName,
+      attribute,
+    });
+  }
+};
+
+module.exports = { registerEnumsDefinition };

package/server/services/content-api/register-functions/content-type/filters.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const registerFiltersDefinition = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { getFiltersInputTypeName } = getService('utils').naming;
+  const { KINDS } = getService('constants');
+
+  const type = getFiltersInputTypeName(contentType);
+  const definition = builders.buildContentTypeFilters(contentType);
+
+  registry.register(type, definition, { kind: KINDS.filtersInput, contentType });
+};
+
+module.exports = { registerFiltersDefinition };

package/server/services/content-api/register-functions/content-type/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { registerDynamicZonesDefinition } = require('./dynamic-zones');
+const { registerEnumsDefinition } = require('./enums');
+const { registerInputsDefinition } = require('./inputs');
+const { registerFiltersDefinition } = require('./filters');
+
+module.exports = {
+  registerDynamicZonesDefinition,
+  registerFiltersDefinition,
+  registerInputsDefinition,
+  registerEnumsDefinition,
+};

package/server/services/content-api/register-functions/content-type/inputs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const registerInputsDefinition = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { getComponentInputName, getContentTypeInputName } = getService('utils').naming;
+  const { KINDS } = getService('constants');
+
+  const { modelType } = contentType;
+
+  const type = (modelType === 'component' ? getComponentInputName : getContentTypeInputName).call(
+    null,
+    contentType
+  );
+
+  const definition = builders.buildInputType(contentType);
+
+  registry.register(type, definition, { kind: KINDS.input, contentType });
+};
+
+module.exports = { registerInputsDefinition };

package/server/services/content-api/register-functions/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { registerCollectionType } = require('./collection-type');
+const { registerSingleType } = require('./single-type');
+const { registerComponent } = require('./component');
+const { registerPolymorphicContentType } = require('./polymorphic');
+
+const { registerScalars } = require('./scalars');
+const { registerInternals } = require('./internals');
+
+const contentType = require('./content-type');
+
+module.exports = {
+  registerCollectionType,
+  registerSingleType,
+  registerComponent,
+  registerPolymorphicContentType,
+  registerInternals,
+  registerScalars,
+
+  contentType,
+};

package/server/services/content-api/register-functions/internals.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const registerInternals = ({ registry, strapi }) => {
+  const { buildInternalTypes } = strapi.plugin('graphql').service('internals');
+
+  const internalTypes = buildInternalTypes({ strapi });
+
+  for (const [kind, definitions] of Object.entries(internalTypes)) {
+    registry.registerMany(Object.entries(definitions), { kind });
+  }
+};
+
+module.exports = { registerInternals };

package/server/services/content-api/register-functions/polymorphic.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { unionType } = require('nexus');
+
+const registerPolymorphicContentType = (contentType, { registry, strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const {
+    naming,
+    attributes: { isMorphRelation },
+  } = getService('utils');
+  const { KINDS } = getService('constants');
+
+  const { attributes = {} } = contentType;
+
+  // Isolate its polymorphic attributes
+  const morphAttributes = Object.entries(attributes).filter(([, attribute]) =>
+    isMorphRelation(attribute)
+  );
+
+  // For each one of those polymorphic attribute
+  for (const [attributeName, attribute] of morphAttributes) {
+    const name = naming.getMorphRelationTypeName(contentType, attributeName);
+    const { target } = attribute;
+
+    // Ignore those whose target is not an array
+    if (!Array.isArray(target)) {
+      continue;
+    }
+
+    // Transform target UIDs into types names
+    const members = target
+      // Get content types definitions
+      .map(uid => strapi.getModel(uid))
+      // Resolve types names
+      .map(contentType => naming.getTypeName(contentType));
+
+    // Register the new polymorphic union type
+    registry.register(
+      name,
+
+      unionType({
+        name,
+
+        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) {
+          t.members(...members);
+        },
+      }),
+
+      { kind: KINDS.morph, contentType, attributeName }
+    );
+  }
+};
+
+module.exports = { registerPolymorphicContentType };

package/server/services/content-api/register-functions/scalars.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const registerScalars = ({ registry, strapi }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { scalars } = getService('internals');
+  const { KINDS } = getService('constants');
+
+  Object.entries(scalars).forEach(([name, definition]) => {
+    registry.register(name, definition, { kind: KINDS.scalar });
+  });
+};
+
+module.exports = { registerScalars };

package/server/services/content-api/register-functions/single-type.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const registerSingleType = (contentType, { registry, strapi, builders }) => {
+  const { service: getService } = strapi.plugin('graphql');
+
+  const { naming } = getService('utils');
+  const { KINDS } = getService('constants');
+
+  const extension = getService('extension');
+
+  const types = {
+    base: naming.getTypeName(contentType),
+    entity: naming.getEntityName(contentType),
+    response: naming.getEntityResponseName(contentType),
+    responseCollection: naming.getEntityResponseCollectionName(contentType),
+    relationResponseCollection: naming.getRelationResponseCollectionName(contentType),
+    queries: naming.getEntityQueriesTypeName(contentType),
+    mutations: naming.getEntityMutationsTypeName(contentType),
+  };
+
+  const getConfig = kind => ({ kind, contentType });
+
+  // Single type's definition
+  registry.register(types.base, builders.buildTypeDefinition(contentType), getConfig(KINDS.type));
+
+  // Higher level entity definition
+  registry.register(
+    types.entity,
+    builders.buildEntityDefinition(contentType),
+    getConfig(KINDS.entity)
+  );
+
+  // Responses definition
+  registry.register(
+    types.response,
+    builders.buildResponseDefinition(contentType),
+    getConfig(KINDS.entityResponse)
+  );
+
+  // Response collection definition
+  registry.register(
+    types.responseCollection,
+    builders.buildResponseCollectionDefinition(contentType),
+    getConfig(KINDS.entityResponseCollection)
+  );
+
+  registry.register(
+    types.relationResponseCollection,
+    builders.buildRelationResponseCollectionDefinition(contentType),
+    getConfig(KINDS.relationResponseCollection)
+  );
+
+  if (extension.shadowCRUD(contentType.uid).areQueriesEnabled()) {
+    // Queries
+    registry.register(
+      types.queries,
+      builders.buildSingleTypeQueries(contentType),
+      getConfig(KINDS.query)
+    );
+  }
+
+  if (extension.shadowCRUD(contentType.uid).areMutationsEnabled()) {
+    // Mutations
+    registry.register(
+      types.mutations,
+      builders.buildSingleTypeMutations(contentType),
+      getConfig(KINDS.mutation)
+    );
+  }
+};
+
+module.exports = { registerSingleType };