@strapi/plugin-graphql 4.0.0-next.8 → 4.0.2

package/server/services/constants.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const PAGINATION_TYPE_NAME = 'Pagination';
+const PUBLICATION_STATE_TYPE_NAME = 'PublicationState';
+const ERROR_TYPE_NAME = 'Error';
+
+const RESPONSE_COLLECTION_META_TYPE_NAME = 'ResponseCollectionMeta';
+
+const GRAPHQL_SCALARS = [
+  'ID',
+  'Boolean',
+  'Int',
+  'String',
+  'Long',
+  'Float',
+  'JSON',
+  'Date',
+  'Time',
+  'DateTime',
+];
+
+const STRAPI_SCALARS = [
+  'boolean',
+  'integer',
+  'string',
+  'richtext',
+  'enumeration',
+  'biginteger',
+  'float',
+  'decimal',
+  'json',
+  'date',
+  'time',
+  'datetime',
+  'timestamp',
+  'uid',
+  'email',
+  'password',
+  'text',
+];
+
+const SCALARS_ASSOCIATIONS = {
+  uid: 'String',
+  email: 'String',
+  password: 'String',
+  text: 'String',
+  boolean: 'Boolean',
+  integer: 'Int',
+  string: 'String',
+  enumeration: 'String',
+  richtext: 'String',
+  biginteger: 'Long',
+  float: 'Float',
+  decimal: 'Float',
+  json: 'JSON',
+  date: 'Date',
+  time: 'Time',
+  datetime: 'DateTime',
+  timestamp: 'DateTime',
+};
+
+const GENERIC_MORPH_TYPENAME = 'GenericMorph';
+
+const KINDS = {
+  type: 'type',
+  component: 'component',
+  dynamicZone: 'dynamic-zone',
+  enum: 'enum',
+  entity: 'entity',
+  entityResponse: 'entity-response',
+  entityResponseCollection: 'entity-response-collection',
+  relationResponseCollection: 'relation-response-collection',
+  query: 'query',
+  mutation: 'mutation',
+  input: 'input',
+  filtersInput: 'filters-input',
+  scalar: 'scalar',
+  morph: 'polymorphic',
+  internal: 'internal',
+};
+
+const allOperators = [
+  'and',
+  'or',
+  'not',
+
+  'eq',
+  'ne',
+
+  'startsWith',
+  'endsWith',
+
+  'contains',
+  'notContains',
+
+  'containsi',
+  'notContainsi',
+
+  'gt',
+  'gte',
+
+  'lt',
+  'lte',
+
+  'null',
+  'notNull',
+
+  'in',
+  'notIn',
+
+  'between',
+];
+
+const GRAPHQL_SCALAR_OPERATORS = {
+  // ID
+  ID: allOperators,
+  // Booleans
+  Boolean: allOperators,
+  // Strings
+  String: allOperators,
+  // Numbers
+  Int: allOperators,
+  Long: allOperators,
+  Float: allOperators,
+  // Dates
+  Date: allOperators,
+  Time: allOperators,
+  DateTime: allOperators,
+  // Others
+  JSON: allOperators,
+};
+
+const ERROR_CODES = {
+  emptyDynamicZone: 'dynamiczone.empty',
+};
+
+module.exports = () => ({
+  PAGINATION_TYPE_NAME,
+  RESPONSE_COLLECTION_META_TYPE_NAME,
+  PUBLICATION_STATE_TYPE_NAME,
+  GRAPHQL_SCALARS,
+  STRAPI_SCALARS,
+  GENERIC_MORPH_TYPENAME,
+  KINDS,
+  GRAPHQL_SCALAR_OPERATORS,
+  SCALARS_ASSOCIATIONS,
+  ERROR_CODES,
+  ERROR_TYPE_NAME,
+});

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

@@ -0,0 +1,179 @@
+'use strict';
+
+const {
+  mergeSchemas,
+  makeExecutableSchema,
+  addResolversToSchema,
+} = require('@graphql-tools/schema');
+const { pruneSchema } = require('@graphql-tools/utils');
+const { makeSchema } = require('nexus');
+const { 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');
+  const extensionService = getGraphQLService('extension');
+
+  // Type Registry
+  let registry;
+  // Builders Instances
+  let builders;
+
+  const buildSchema = () => {
+    const isShadowCRUDEnabled = !!config('shadowCRUD');
+
+    // 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();
+    }
+
+    // Build a collection of schema based on the type registry (& temporary generated extension)
+    const schemas = buildSchemas({ registry });
+
+    // Merge every created schema into a single one
+    const mergedSchema = mergeSchemas({ schemas });
+
+    // Generate the extension configuration for the content API.
+    // This extension instance needs to be generated after the Nexus schema's
+    // generation, so that configurations created during types definitions
+    // can be registered before being used in the wrap resolvers operation
+    const extension = extensionService.generate({ typeRegistry: registry });
+
+    // Add the extension's resolvers to the final schema
+    const schema = addResolversToSchema(mergedSchema, extension.resolvers);
+
+    // Wrap resolvers if needed (auth, middlewares, policies...) as configured in the extension
+    const wrappedSchema = wrapResolvers({ schema, strapi, extension });
+
+    // Prune schema, remove unused types
+    // eg: removes registered subscriptions if they're disabled in the config)
+    const prunedSchema = pruneSchema(wrappedSchema);
+
+    return prunedSchema;
+  };
+
+  const buildSchemas = ({ registry }) => {
+    // Here we extract types, plugins & typeDefs from a temporary generated
+    // extension since there won't be any addition allowed after schemas generation
+    const { types, plugins, typeDefs = [] } = extensionService.generate({ typeRegistry: registry });
+
+    // 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,60 @@
+'use strict';
+
+const { propOr } = require('lodash/fp');
+const { policy: policyUtils } = require('@strapi/utils');
+const { ForbiddenError } = require('@strapi/utils').errors;
+
+const getPoliciesConfig = propOr([], 'policies');
+
+const createPoliciesMiddleware = (resolverConfig, { strapi }) => {
+  const resolverPolicies = getPoliciesConfig(resolverConfig);
+  const policies = policyUtils.resolve(resolverPolicies);
+
+  return async (resolve, ...rest) => {
+    // Create a graphql policy context
+    const context = createGraphQLPolicyContext(...rest);
+
+    // Run policies & throw an error if one of them fails
+    for (const { handler, config } of policies) {
+      const result = await handler(context, config, { strapi });
+
+      if (![true, undefined].includes(result)) {
+        throw new ForbiddenError('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 };