@strapi/plugin-graphql 4.15.5 → 4.16.1

package/server/services/constants.js

@@ -1,153 +0,0 @@
-'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',
-  'blocks',
-  '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',
-  blocks: 'JSON',
-  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',
-  'eqi',
-  'ne',
-  'nei',
-
-  '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

@@ -1,188 +0,0 @@
-'use strict';
-
-const { mergeSchemas, 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 merged schema from both Nexus types & SDL type definitions
-    const schema = buildMergedSchema({ registry });
-
-    // 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 schemaWithResolvers = addResolversToSchema(schema, extension.resolvers);
-
-    // Create a configuration object for the artifacts generation
-    const outputs = {
-      schema: config('artifacts.schema', false),
-      typegen: config('artifacts.typegen', false),
-    };
-
-    const currentEnv = strapi.config.get('environment');
-
-    const nexusSchema = makeSchema({
-      // Build the schema from the merged GraphQL schema.
-      // Since we're passing the schema to the mergeSchema property, it'll transform our SDL type definitions
-      // into Nexus type definition, thus allowing them to be handled by  Nexus plugins & other processing
-      mergeSchema: { schema: schemaWithResolvers },
-
-      // Apply user-defined plugins
-      plugins: extension.plugins,
-
-      // Whether to generate artifacts (GraphQL schema, TS types definitions) or not.
-      // By default, we generate artifacts only on development environment
-      shouldGenerateArtifacts: config('generateArtifacts', currentEnv === 'development'),
-
-      // Artifacts generation configuration
-      outputs,
-    });
-
-    // Wrap resolvers if needed (auth, middlewares, policies...) as configured in the extension
-    const wrappedNexusSchema = wrapResolvers({ schema: nexusSchema, strapi, extension });
-
-    // Prune schema, remove unused types
-    // eg: removes registered subscriptions if they're disabled in the config)
-    const prunedNexusSchema = pruneSchema(wrappedNexusSchema);
-
-    return prunedNexusSchema;
-  };
-
-  const buildMergedSchema = ({ 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, typeDefs = [] } = extensionService.generate({ typeRegistry: registry });
-
-    // Nexus schema built with user-defined & shadow CRUD auto generated Nexus types
-    const nexusSchema = makeSchema({ types: [registry.definitions, types] });
-
-    // Merge type definitions with the Nexus schema
-    return mergeSchemas({
-      typeDefs,
-      // Give access to the shadowCRUD & nexus based types
-      // Note: This is necessary so that types defined in SDL can reference types defined with Nexus
-      schemas: [nexusSchema],
-    });
-  };
-
-  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

@@ -1,60 +0,0 @@
-'use strict';
-
-const { propOr } = require('lodash/fp');
-const { policy: policyUtils } = require('@strapi/utils');
-const { PolicyError } = 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 PolicyError();
-      }
-    }
-
-    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

@@ -1,72 +0,0 @@
-'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

@@ -1,15 +0,0 @@
-'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

@@ -1,36 +0,0 @@
-'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

@@ -1,33 +0,0 @@
-'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

@@ -1,15 +0,0 @@
-'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

@@ -1,13 +0,0 @@
-'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

@@ -1,21 +0,0 @@
-'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

@@ -1,22 +0,0 @@
-'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

@@ -1,13 +0,0 @@
-'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 };