@strapi/plugin-graphql 5.12.1 → 5.12.3

package/dist/server/index.js

@@ -1,3726 +1,13 @@
 'use strict';
 
-var fp = require('lodash/fp');
-var server = require('@apollo/server');
-var _default = require('@apollo/server/plugin/landingPage/default');
-var koa = require('@as-integrations/koa');
-var depthLimit = require('graphql-depth-limit');
-var bodyParser = require('koa-bodyparser');
-var cors = require('@koa/cors');
-var utils$2 = require('@strapi/utils');
-var errors = require('@apollo/server/errors');
-var graphql = require('graphql');
-var utils$3 = require('@graphql-tools/utils');
-var nexus = require('nexus');
-var pluralize = require('pluralize');
-var graphqlScalars = require('graphql-scalars');
-
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var nexus__namespace = /*#__PURE__*/_interopNamespaceDefault(nexus);
-
-var defaultConfig = {
-    shadowCRUD: true,
-    endpoint: '/graphql',
-    subscriptions: false,
-    maxLimit: -1,
-    apolloServer: {},
-    v4CompatibilityMode: process.env.STRAPI_GRAPHQL_V4_COMPATIBILITY_MODE ?? false
-};
-
-const config = {
-    default: defaultConfig
-};
-
-const { HttpError, ForbiddenError: ForbiddenError$1, UnauthorizedError, ApplicationError: ApplicationError$5, ValidationError: ValidationError$3 } = utils$2.errors;
-const formatToCode = (name)=>`STRAPI_${fp.toUpper(fp.snakeCase(name))}`;
-const formatErrorToExtension = (error)=>({
-        error: fp.pick([
-            'name',
-            'message',
-            'details'
-        ])(error)
-    });
-function createFormattedError(formattedError, message, code, originalError) {
-    const options = {
-        ...formattedError,
-        extensions: {
-            ...formattedError.extensions,
-            ...formatErrorToExtension(originalError),
-            code
-        }
-    };
-    return new graphql.GraphQLError(message, options);
-}
-/**
- * The handler for Apollo Server v4's formatError config option
- *
- * Intercepts specific Strapi error types to send custom error response codes in the GraphQL response
- */ function formatGraphqlError(formattedError, error) {
-    const originalError = errors.unwrapResolverError(error);
-    // If this error doesn't have an associated originalError, it
-    if (fp.isEmpty(originalError)) {
-        return formattedError;
-    }
-    const { message = '', name = 'UNKNOWN' } = originalError;
-    if (originalError instanceof ForbiddenError$1 || originalError instanceof UnauthorizedError) {
-        return createFormattedError(formattedError, message, 'FORBIDDEN', originalError);
-    }
-    if (originalError instanceof ValidationError$3) {
-        return createFormattedError(formattedError, message, 'BAD_USER_INPUT', originalError);
-    }
-    if (originalError instanceof ApplicationError$5 || originalError instanceof HttpError) {
-        const errorName = formatToCode(name);
-        return createFormattedError(formattedError, message, errorName, originalError);
-    }
-    if (originalError instanceof graphql.GraphQLError) {
-        return formattedError;
-    }
-    // else if originalError doesn't appear to be from Strapi or GraphQL..
-    // Log the error
-    strapi.log.error(originalError);
-    // Create a generic 500 to send so we don't risk leaking any data
-    return createFormattedError(new graphql.GraphQLError('Internal Server Error'), 'Internal Server Error', 'INTERNAL_SERVER_ERROR', originalError);
-}
-
-const merge = fp.mergeWith((a, b)=>{
-    if (fp.isArray(a) && fp.isArray(b)) {
-        return a.concat(b);
-    }
-});
-const determineLandingPage = (strapi)=>{
-    const { config } = strapi.plugin('graphql');
-    const utils = strapi.plugin('graphql').service('utils');
-    /**
-   * configLanding page may be one of the following:
-   *
-   * - true: always use "playground" even in production
-   * - false: never show "playground" even in non-production
-   * - undefined: default Apollo behavior (hide playground on production)
-   * - a function that returns an Apollo plugin that implements renderLandingPage
-   ** */ const configLandingPage = config('landingPage');
-    const isProduction = process.env.NODE_ENV === 'production';
-    const localLanding = ()=>{
-        strapi.log.debug('Apollo landing page: local');
-        utils.playground.setEnabled(true);
-        return _default.ApolloServerPluginLandingPageLocalDefault();
-    };
-    const prodLanding = ()=>{
-        strapi.log.debug('Apollo landing page: production');
-        utils.playground.setEnabled(false);
-        return _default.ApolloServerPluginLandingPageProductionDefault();
-    };
-    const userLanding = (userFunction)=>{
-        strapi.log.debug('Apollo landing page: from user-defined function...');
-        const result = userFunction(strapi);
-        if (result === true) {
-            return localLanding();
-        }
-        if (result === false) {
-            return prodLanding();
-        }
-        strapi.log.debug('Apollo landing page: user-defined');
-        return result;
-    };
-    // DEPRECATED, remove in Strapi v6
-    const playgroundAlways = config('playgroundAlways');
-    if (playgroundAlways !== undefined) {
-        strapi.log.warn('The graphql config playgroundAlways is deprecated. This will be removed in Strapi 6. Please use landingPage instead. ');
-    }
-    if (playgroundAlways === false) {
-        strapi.log.warn('graphql config playgroundAlways:false has no effect, please use landingPage:false to disable Graphql Playground in all environments');
-    }
-    if (playgroundAlways || configLandingPage === true) {
-        return localLanding();
-    }
-    // if landing page has been disabled, use production
-    if (configLandingPage === false) {
-        return prodLanding();
-    }
-    // If user did not define any settings, use our defaults
-    if (configLandingPage === undefined) {
-        return isProduction ? prodLanding() : localLanding();
-    }
-    // if user provided a landing page function, return that
-    if (fp.isFunction(configLandingPage)) {
-        return userLanding(configLandingPage);
-    }
-    // If no other setting could be found, default to production settings
-    strapi.log.warn('Your Graphql landing page has been disabled because there is a problem with your Graphql settings');
-    return prodLanding();
-};
-async function bootstrap({ strapi }) {
-    // Generate the GraphQL schema for the content API
-    const schema = strapi.plugin('graphql').service('content-api').buildSchema();
-    if (fp.isEmpty(schema)) {
-        strapi.log.warn('The GraphQL schema has not been generated because it is empty');
-        return;
-    }
-    const { config } = strapi.plugin('graphql');
-    const path = config('endpoint');
-    const landingPage = determineLandingPage(strapi);
-    const defaultServerConfig = {
-        // Schema
-        schema,
-        // Validation
-        validationRules: [
-            depthLimit(config('depthLimit'))
-        ],
-        // Errors
-        formatError: formatGraphqlError,
-        // Misc
-        cors: false,
-        uploads: false,
-        bodyParserConfig: true,
-        // send 400 http status instead of 200 for input validation errors
-        status400ForVariableCoercionErrors: true,
-        plugins: [
-            landingPage
-        ],
-        cache: 'bounded'
-    };
-    const serverConfig = merge(defaultServerConfig, config('apolloServer'));
-    // Create a new Apollo server
-    const server$1 = new server.ApolloServer(serverConfig);
-    try {
-        // server.start() must be called before using server.applyMiddleware()
-        await server$1.start();
-    } catch (error) {
-        if (error instanceof Error) {
-            strapi.log.error('Failed to start the Apollo server', error.message);
-        }
-        throw error;
-    }
-    // Create the route handlers for Strapi
-    const handler = [];
-    // add cors middleware
-    if (cors) {
-        handler.push(cors());
-    }
-    // add koa bodyparser middleware
-    if (fp.isObject(serverConfig.bodyParserConfig)) {
-        handler.push(bodyParser(serverConfig.bodyParserConfig));
-    } else if (serverConfig.bodyParserConfig) {
-        handler.push(bodyParser());
-    } else {
-        strapi.log.debug('Body parser has been disabled for Apollo server');
-    }
-    // add the Strapi auth middleware
-    handler.push((ctx, next)=>{
-        ctx.state.route = {
-            info: {
-                // Indicate it's a content API route
-                type: 'content-api'
-            }
-        };
-        const isPlaygroundRequest = ctx.request.method === 'GET' && ctx.request.url === path && // Matches the GraphQL endpoint
-        strapi.plugin('graphql').service('utils').playground.isEnabled() && // Only allow if the Playground is enabled
-        ctx.request.header.accept?.includes('text/html'); // Specific to Playground UI loading
-        // Skip authentication for the GraphQL Playground UI
-        if (isPlaygroundRequest) {
-            return next();
-        }
-        return strapi.auth.authenticate(ctx, next);
-    });
-    // add the graphql server for koa
-    handler.push(koa.koaMiddleware(server$1, {
-        // Initialize loaders for this request.
-        context: async ({ ctx })=>({
-                state: ctx.state,
-                koaContext: ctx
-            })
-    }));
-    // now that handlers are set up, add the graphql route to our apollo server
-    strapi.server.routes([
-        {
-            method: 'ALL',
-            path,
-            handler,
-            config: {
-                auth: false
-            }
-        }
-    ]);
-    // Register destroy behavior
-    // We're doing it here instead of exposing a destroy method to the strapi-server.js
-    // file since we need to have access to the ApolloServer instance
-    strapi.plugin('graphql').destroy = async ()=>{
-        await server$1.stop();
-    };
-}
-
-const { PolicyError } = utils$2.errors;
-const getPoliciesConfig = fp.propOr([], 'policies');
-const createPoliciesMiddleware = (resolverConfig, { strapi })=>{
-    const resolverPolicies = getPoliciesConfig(resolverConfig);
-    const policies = strapi.get('policies').resolve(resolverPolicies, {});
-    return async (resolve, parent, args, context, info)=>{
-        // Create a graphql policy context
-        const policyContext = createGraphQLPolicyContext(parent, args, context, info);
-        // Run policies & throw an error if one of them fails
-        for (const { handler, config } of policies){
-            const result = await handler(policyContext, config, {
-                strapi
-            });
-            if (![
-                true,
-                undefined
-            ].includes(result)) {
-                throw new PolicyError();
-            }
-        }
-        return resolve(parent, args, context, info);
-    };
-};
-const createGraphQLPolicyContext = (parent, args, context, info)=>{
-    const policyContext = {
-        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;
-        }
-    };
-    return utils$2.policy.createPolicyContext('graphql', policyContext);
-};
-
-const { ForbiddenError } = utils$2.errors;
-const introspectionQueries = [
-    '__Schema',
-    '__Type',
-    '__Field',
-    '__InputValue',
-    '__EnumValue',
-    '__Directive'
-];
-/**
- * Get & parse middlewares definitions from the resolver's config
- * @param {object} resolverConfig
- * @param {object} strapi
- * @return {function[]}
- */ const parseMiddlewares = (resolverConfig, strapi)=>{
-    const resolverMiddlewares = fp.getOr([], 'middlewares', resolverConfig);
-    // TODO: [v4] to factorize with compose endpoints (routes)
-    return resolverMiddlewares.map((middleware)=>{
-        if (fp.isFunction(middleware)) {
-            return middleware;
-        }
-        if (typeof middleware === 'string') {
-            return strapi.middleware(middleware);
-        }
-        if (typeof middleware === 'object') {
-            const { name, options = {} } = middleware;
-            return strapi.middleware(name)(options, {
-                strapi
-            });
-        }
-        throw new Error(`Invalid middleware type, expected (function,string,object), received ${typeof middleware}`);
-    });
-};
-/**
- * Wrap the schema's resolvers if they've been
- * customized using the GraphQL extension service
- * @param {object} options
- * @param {GraphQLSchema} options.schema
- * @param {object} options.strapi
- * @param {object} options.extension
- * @return {GraphQLSchema}
- */ const wrapResolvers = ({ schema, strapi, extension = {} })=>{
-    // Get all the registered resolvers configuration
-    const { resolversConfig = {} } = extension;
-    // Fields filters
-    const isValidFieldName = (field)=>!field.startsWith('__');
-    const typeMap = schema.getTypeMap();
-    Object.entries(typeMap).forEach(([type, definition])=>{
-        const isGraphQLObjectType = definition instanceof graphql.GraphQLObjectType;
-        const isIgnoredType = introspectionQueries.includes(type);
-        if (!isGraphQLObjectType || isIgnoredType) {
-            return;
-        }
-        const fields = definition.getFields();
-        const fieldsToProcess = Object.entries(fields).filter(([field])=>isValidFieldName(field));
-        for (const [fieldName, fieldDefinition] of fieldsToProcess){
-            const defaultResolver = fp.get(fieldName);
-            const path = `${type}.${fieldName}`;
-            const resolverConfig = fp.getOr({}, path, resolversConfig);
-            const { resolve: baseResolver = defaultResolver } = fieldDefinition;
-            // Parse & initialize the middlewares
-            const middlewares = parseMiddlewares(resolverConfig, strapi);
-            // Generate the policy middleware
-            const policyMiddleware = createPoliciesMiddleware(resolverConfig, {
-                strapi
-            });
-            // Add the policyMiddleware at the end of the middlewares collection
-            middlewares.push(policyMiddleware);
-            // Bind every middleware to the next one
-            const boundMiddlewares = middlewares.map((middleware, index, collection)=>{
-                return (parents, args, context, info)=>middleware(// Make sure the last middleware in the list calls the baseResolver
-                    index >= collection.length - 1 ? baseResolver : boundMiddlewares[index + 1], parents, args, context, info);
-            });
-            /**
-       * GraphQL authorization flow
-       * @param {object} context
-       * @return {Promise<void>}
-       */ const authorize = async ({ context })=>{
-                const authConfig = fp.get('auth', resolverConfig);
-                const authContext = fp.get('state.auth', context);
-                const isValidType = [
-                    'Mutation',
-                    'Query',
-                    'Subscription'
-                ].includes(type);
-                const hasConfig = !fp.isNil(authConfig);
-                const isAuthDisabled = authConfig === false;
-                if ((isValidType || hasConfig) && !isAuthDisabled) {
-                    try {
-                        await strapi.auth.verify(authContext, authConfig);
-                    } catch (error) {
-                        throw new ForbiddenError();
-                    }
-                }
-            };
-            /**
-       * Base resolver wrapper that handles authorization, middlewares & policies
-       * @return {Promise<any>}
-       */ fieldDefinition.resolve = async (parent, args, context, info)=>{
-                await authorize({
-                    context
-                });
-                // Execute middlewares (including the policy middleware which will always be included)
-                return fp.first(boundMiddlewares)(parent, args, context, info);
-            };
-        }
-    });
-    return schema;
-};
-
-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));
-    }
-};
-
-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));
-    }
-};
-
-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
-    });
-};
-
-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, nexus.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
-        });
-    }
-};
-
-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
-        });
-    });
-};
-
-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
-        });
-    }
-};
-
-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
-        });
-    }
-};
-
-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
-        });
-    }
-};
-
-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
-    });
-};
-
-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
-    });
-};
-
-var contentAPI = (({ strapi })=>{
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { mergeSchemas, addResolversToSchema } = require('@graphql-tools/schema');
-    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,
-            resolvers: 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 = nexus.makeSchema({
-            types: [],
-            // 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 = utils$3.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 = nexus.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(fp.prop('uid')).filter(fp.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 { 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);
-                continue;
-            }
-            const { kind } = contentType;
-            // Generate & register single type's definition
-            if (kind === 'singleType') {
-                registerSingleType(contentType, registerOptions);
-            } 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
-    };
-});
-
-const { ApplicationError: ApplicationError$4 } = utils$2.errors;
-/**
- * Create a new type registry
- */ const createTypeRegistry = ()=>{
-    const registry = new Map();
-    const typeRegistry = {
-        /**
-     * Register a new type definition
-     */ register (name, definition, config = {}) {
-            if (registry.has(name)) {
-                throw new ApplicationError$4(`"${name}" has already been registered`);
-            }
-            registry.set(name, {
-                name,
-                definition,
-                config
-            });
-            return this;
-        },
-        /**
-     * Register many types definitions at once
-     * @param {[string, NexusAcceptedTypeDef][]} definitionsEntries
-     * @param {object | function} [config]
-     */ registerMany (definitionsEntries, config = {}) {
-            for (const [name, definition] of definitionsEntries){
-                this.register(name, definition, fp.isFunction(config) ? config(name, definition) : config);
-            }
-            return this;
-        },
-        /**
-     * Check if the given type name has already been added to the registry
-     * @param {string} name
-     * @return {boolean}
-     */ has (name) {
-            return registry.has(name);
-        },
-        /**
-     * Get the type definition for `name`
-     * @param {string} name - The name of the type
-     */ get (name) {
-            return registry.get(name);
-        },
-        /**
-     * Transform and return the registry as an object
-     * @return {Object<string, RegisteredTypeDef>}
-     */ toObject () {
-            return Object.fromEntries(registry.entries());
-        },
-        /**
-     * Return the name of every registered type
-     * @return {string[]}
-     */ get types () {
-            return Array.from(registry.keys());
-        },
-        /**
-     * Return all the registered definitions as an array
-     * @return {RegisteredTypeDef[]}
-     */ get definitions () {
-            return Array.from(registry.values());
-        },
-        /**
-     * Filter and return the types definitions that matches the given predicate
-     * @param {function(RegisteredTypeDef): boolean} predicate
-     * @return {RegisteredTypeDef[]}
-     */ where (predicate) {
-            return this.definitions.filter(predicate);
-        }
-    };
-    return typeRegistry;
-};
-var typeRegistry = (()=>({
-        new: createTypeRegistry
-    }));
-
-const { ApplicationError: ApplicationError$3 } = utils$2.errors;
-var strapiScalarToGraphQLScalar = (({ strapi })=>{
-    const { STRAPI_SCALARS, SCALARS_ASSOCIATIONS } = strapi.plugin('graphql').service('constants');
-    const missingStrapiScalars = fp.difference(STRAPI_SCALARS, Object.keys(SCALARS_ASSOCIATIONS));
-    if (missingStrapiScalars.length > 0) {
-        throw new ApplicationError$3('Some Strapi scalars are not handled in the GraphQL scalars mapper');
-    }
-    return {
-        /**
-     * Used to transform a Strapi scalar type into its GraphQL equivalent
-     */ strapiScalarToGraphQLScalar (strapiScalar) {
-            return fp.get(strapiScalar, SCALARS_ASSOCIATIONS);
-        }
-    };
-});
-
-// todo[v4]: Find a way to get that dynamically
-const virtualScalarAttributes = [
-    'id',
-    'documentId'
-];
-var graphQLFiltersToStrapiQuery = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    const recursivelyReplaceScalarOperators = (data)=>{
-        const { operators } = getService('builders').filters;
-        if (Array.isArray(data)) {
-            return data.map(recursivelyReplaceScalarOperators);
-        }
-        // Note: We need to make an exception for date since GraphQL
-        // automatically cast date strings to date instances in args
-        if (fp.isDate(data) || !fp.isObject(data)) {
-            return data;
-        }
-        const result = {};
-        for (const [key, value] of Object.entries(data)){
-            const isOperator = !!operators[key];
-            const newKey = isOperator ? operators[key].strapiOperator : key;
-            result[newKey] = recursivelyReplaceScalarOperators(value);
-        }
-        return result;
-    };
-    return {
-        /**
-     * Transform one or many GraphQL filters object into a valid Strapi query
-     * @param {object | object[]} filters
-     * @param {object} contentType
-     * @return {object | object[]}
-     */ graphQLFiltersToStrapiQuery (filters, contentType) {
-            const { isStrapiScalar, isMedia, isRelation, isComponent } = getService('utils').attributes;
-            const { operators } = getService('builders').filters;
-            const ROOT_LEVEL_OPERATORS = [
-                operators.and,
-                operators.or,
-                operators.not
-            ];
-            // Handle unwanted scenario where there is no filters defined
-            if (fp.isNil(filters)) {
-                return {};
-            }
-            // If filters is a collection, then apply the transformation to every item of the list
-            if (Array.isArray(filters)) {
-                return filters.map((filtersItem)=>this.graphQLFiltersToStrapiQuery(filtersItem, contentType));
-            }
-            const resultMap = {};
-            const { attributes } = contentType;
-            const isAttribute = (attributeName)=>{
-                return virtualScalarAttributes.includes(attributeName) || fp.has(attributeName, attributes);
-            };
-            for (const [key, value] of Object.entries(filters)){
-                // If the key is an attribute, update the value
-                if (isAttribute(key)) {
-                    const attribute = attributes[key];
-                    // If it's a scalar attribute
-                    if (virtualScalarAttributes.includes(key) || isStrapiScalar(attribute)) {
-                        // Replace (recursively) every GraphQL scalar operator with the associated Strapi operator
-                        resultMap[key] = recursivelyReplaceScalarOperators(value);
-                    } else if (isRelation(attribute) || isMedia(attribute)) {
-                        // Fetch the model from the relation
-                        const relModel = strapi.getModel(attribute.target);
-                        // Recursively apply the mapping to the value using the fetched model,
-                        // and update the value within `resultMap`
-                        resultMap[key] = this.graphQLFiltersToStrapiQuery(value, relModel);
-                    } else if (isComponent(attribute)) {
-                        // Fetch the model from the component attribute
-                        const componentModel = strapi.getModel(attribute.component);
-                        // Recursively apply the mapping to the value using the fetched model,
-                        // and update the value within `resultMap`
-                        resultMap[key] = this.graphQLFiltersToStrapiQuery(value, componentModel);
-                    }
-                } else {
-                    const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(fp.propEq('fieldName', key));
-                    // If it's a root level operator (AND, NOT, OR, ...)
-                    if (rootLevelOperator) {
-                        const { strapiOperator } = rootLevelOperator;
-                        // Transform the current value recursively and add it to the resultMap
-                        // object using the strapiOperator equivalent of the GraphQL key
-                        resultMap[strapiOperator] = this.graphQLFiltersToStrapiQuery(value, contentType);
-                    }
-                }
-            }
-            return resultMap;
-        }
-    };
-});
-
-var graphqlScalarToOperators = (({ strapi })=>({
-        graphqlScalarToOperators (graphqlScalar) {
-            const { GRAPHQL_SCALAR_OPERATORS } = strapi.plugin('graphql').service('constants');
-            const { operators } = strapi.plugin('graphql').service('builders').filters;
-            const associations = fp.mapValues(fp.map((operatorName)=>operators[operatorName]), GRAPHQL_SCALAR_OPERATORS);
-            return fp.get(graphqlScalar, associations);
-        }
-    }));
-
-const entityToResponseEntity = (entity)=>({
-        id: entity.id,
-        attributes: entity
-    });
-const entitiesToResponseEntities = fp.map(entityToResponseEntity);
-var entityToResponseEntity$1 = (()=>({
-        entityToResponseEntity,
-        entitiesToResponseEntities
-    }));
-
-var mappers = ((context)=>({
-        ...strapiScalarToGraphQLScalar(context),
-        ...graphQLFiltersToStrapiQuery(context),
-        ...graphqlScalarToOperators(context),
-        ...entityToResponseEntity$1()
-    }));
-
-var attributes = (({ strapi })=>{
-    /**
-   * Check if the given attribute is a Strapi scalar
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isStrapiScalar = (attribute)=>{
-        return strapi.plugin('graphql').service('constants').STRAPI_SCALARS.includes(attribute.type);
-    };
-    /**
-   * Check if the given attribute is a GraphQL scalar
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isGraphQLScalar = (attribute)=>{
-        return strapi.plugin('graphql').service('constants').GRAPHQL_SCALARS.includes(attribute.type);
-    };
-    /**
-   * Check if the given attribute is a polymorphic relation
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isMorphRelation = (attribute)=>{
-        return attribute.type === 'relation' && attribute.relation.includes('morph');
-    };
-    /**
-   * Check if the given attribute is a media
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isMedia = fp.propEq('type', 'media');
-    /**
-   * Check if the given attribute is a relation
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isRelation = fp.propEq('type', 'relation');
-    /**
-   * Check if the given attribute is an enum
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isEnumeration = fp.propEq('type', 'enumeration');
-    /**
-   * Check if the given attribute is a component
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isComponent = fp.propEq('type', 'component');
-    /**
-   * Check if the given attribute is a dynamic zone
-   * @param {object} attribute
-   * @return {boolean}
-   */ const isDynamicZone = fp.propEq('type', 'dynamiczone');
-    return {
-        isStrapiScalar,
-        isGraphQLScalar,
-        isMorphRelation,
-        isMedia,
-        isRelation,
-        isEnumeration,
-        isComponent,
-        isDynamicZone
-    };
-});
-
-const { ApplicationError: ApplicationError$2 } = utils$2.errors;
-var naming = (({ strapi })=>{
-    /**
-   * Build a type name for a enum based on a content type & an attribute name
-   */ const getEnumName = (contentType, attributeName)=>{
-        const { attributes } = contentType;
-        const { enumName } = attributes[attributeName];
-        const { modelType } = contentType;
-        const typeName = modelType === 'component' ? getComponentName(contentType) : getTypeName(contentType);
-        const defaultEnumName = `ENUM_${typeName.toUpperCase()}_${attributeName.toUpperCase()}`;
-        return enumName || defaultEnumName;
-    };
-    /**
-   * Build the base type name for a given content type
-   */ const getTypeName = (contentType, { plurality = 'singular' } = {})=>{
-        const plugin = fp.get('plugin', contentType);
-        const modelName = fp.get('modelName', contentType);
-        const name = plurality === 'singular' ? fp.get('info.singularName', contentType) : fp.get('info.pluralName', contentType);
-        const transformedPlugin = fp.upperFirst(fp.camelCase(plugin));
-        const transformedModelName = fp.upperFirst(fp.camelCase(name || pluralize.singular(modelName)));
-        return `${transformedPlugin}${transformedModelName}`;
-    };
-    /**
-   * Build the entity's type name for a given content type
-   */ const getEntityName = (contentType)=>{
-        return `${getTypeName(contentType)}Entity`;
-    };
-    /**
-   * Build the entity meta type name for a given content type
-   */ const getEntityMetaName = (contentType)=>{
-        return `${getEntityName(contentType)}Meta`;
-    };
-    /**
-   * Build the entity response's type name for a given content type
-   */ const getEntityResponseName = (contentType)=>{
-        return `${getEntityName(contentType)}Response`;
-    };
-    /**
-   * Build the entity response collection's type name for a given content type
-   */ const getEntityResponseCollectionName = (contentType)=>{
-        return `${getEntityName(contentType)}ResponseCollection`;
-    };
-    /**
-   * Build the relation response collection's type name for a given content type
-   */ const getRelationResponseCollectionName = (contentType)=>{
-        return `${getTypeName(contentType)}RelationResponseCollection`;
-    };
-    /**
-   * Build a component type name based on its definition
-   */ const getComponentName = (contentType)=>{
-        return contentType.globalId;
-    };
-    /**
-   * Build a component type name based on a content type's attribute
-   */ const getComponentNameFromAttribute = (attribute)=>{
-        return strapi.components[attribute.component].globalId;
-    };
-    /**
-   * Build a dynamic zone type name based on a content type and an attribute name
-   */ const getDynamicZoneName = (contentType, attributeName)=>{
-        const typeName = getTypeName(contentType);
-        const dzName = fp.upperFirst(fp.camelCase(attributeName));
-        const suffix = 'DynamicZone';
-        return `${typeName}${dzName}${suffix}`;
-    };
-    /**
-   * Build a dynamic zone input type name based on a content type and an attribute name
-   */ const getDynamicZoneInputName = (contentType, attributeName)=>{
-        const dzName = getDynamicZoneName(contentType, attributeName);
-        return `${dzName}Input`;
-    };
-    /**
-   * Build a component input type name based on a content type and an attribute name
-   */ const getComponentInputName = (contentType)=>{
-        const componentName = getComponentName(contentType);
-        return `${componentName}Input`;
-    };
-    /**
-   * Build a content type input name based on a content type and an attribute name
-   */ const getContentTypeInputName = (contentType)=>{
-        const typeName = getTypeName(contentType);
-        return `${typeName}Input`;
-    };
-    /**
-   * Build the queries type name for a given content type
-   */ const getEntityQueriesTypeName = (contentType)=>{
-        return `${getEntityName(contentType)}Queries`;
-    };
-    /**
-   * Build the mutations type name for a given content type
-   */ const getEntityMutationsTypeName = (contentType)=>{
-        return `${getEntityName(contentType)}Mutations`;
-    };
-    /**
-   * Build the filters type name for a given content type
-   */ const getFiltersInputTypeName = (contentType)=>{
-        const isComponent = contentType.modelType === 'component';
-        const baseName = isComponent ? getComponentName(contentType) : getTypeName(contentType);
-        return `${baseName}FiltersInput`;
-    };
-    /**
-   * Build a filters type name for a given GraphQL scalar type
-   */ const getScalarFilterInputTypeName = (scalarType)=>{
-        return `${scalarType}FilterInput`;
-    };
-    /**
-   * Build a type name for a given content type & polymorphic attribute
-   */ const getMorphRelationTypeName = (contentType, attributeName)=>{
-        const typeName = getTypeName(contentType);
-        const formattedAttr = fp.upperFirst(fp.camelCase(attributeName));
-        return `${typeName}${formattedAttr}Morph`;
-    };
-    /**
-   * Build a custom type name generator with different customization options
-   */ const buildCustomTypeNameGenerator = (options)=>{
-        // todo[v4]: use singularName & pluralName is available
-        const { prefix = '', suffix = '', plurality = 'singular', firstLetterCase = 'upper' } = options;
-        if (![
-            'plural',
-            'singular'
-        ].includes(plurality)) {
-            throw new ApplicationError$2(`"plurality" param must be either "plural" or "singular", but got: "${plurality}"`);
-        }
-        const getCustomTypeName = fp.pipe((ct)=>getTypeName(ct, {
-                plurality
-            }), firstLetterCase === 'upper' ? fp.upperFirst : fp.lowerFirst);
-        return (contentType)=>`${prefix}${getCustomTypeName(contentType)}${suffix}`;
-    };
-    const getFindQueryName = buildCustomTypeNameGenerator({
-        plurality: 'plural',
-        firstLetterCase: 'lower'
-    });
-    const getFindConnectionQueryName = (contentType)=>{
-        return `${getFindQueryName(contentType)}_connection`;
-    };
-    const getFindOneQueryName = buildCustomTypeNameGenerator({
-        firstLetterCase: 'lower'
-    });
-    const getCreateMutationTypeName = buildCustomTypeNameGenerator({
-        prefix: 'create',
-        firstLetterCase: 'upper'
-    });
-    const getUpdateMutationTypeName = buildCustomTypeNameGenerator({
-        prefix: 'update',
-        firstLetterCase: 'upper'
-    });
-    const getDeleteMutationTypeName = buildCustomTypeNameGenerator({
-        prefix: 'delete',
-        firstLetterCase: 'upper'
-    });
-    return {
-        getEnumName,
-        getTypeName,
-        getEntityName,
-        getEntityMetaName,
-        getEntityResponseName,
-        getEntityResponseCollectionName,
-        getRelationResponseCollectionName,
-        getComponentName,
-        getComponentNameFromAttribute,
-        getDynamicZoneName,
-        getDynamicZoneInputName,
-        getComponentInputName,
-        getContentTypeInputName,
-        getEntityQueriesTypeName,
-        getEntityMutationsTypeName,
-        getFiltersInputTypeName,
-        getScalarFilterInputTypeName,
-        getMorphRelationTypeName,
-        buildCustomTypeNameGenerator,
-        getFindQueryName,
-        getFindOneQueryName,
-        getCreateMutationTypeName,
-        getUpdateMutationTypeName,
-        getDeleteMutationTypeName,
-        getFindConnectionQueryName
-    };
-});
-
-// TODO: deprecate and remove this because it is only used to determine if we need helmet security exceptions
-// stores the state of the Apollo landingPage (playground)
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-var playground = ((ctx)=>{
-    let enabled = false;
-    return {
-        setEnabled (val) {
-            enabled = val;
-        },
-        isEnabled () {
-            return enabled;
-        }
-    };
-});
-
-var utils$1 = ((context)=>({
-        playground: playground(),
-        naming: naming(context),
-        attributes: attributes(context),
-        mappers: mappers(context)
-    }));
-
-const PAGINATION_TYPE_NAME = 'Pagination';
-const DELETE_MUTATION_RESPONSE_TYPE_NAME = 'DeleteMutationResponse';
-const PUBLICATION_STATUS_TYPE_NAME = 'PublicationStatus';
-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'
-};
-var constants = (()=>({
-        PAGINATION_TYPE_NAME,
-        RESPONSE_COLLECTION_META_TYPE_NAME,
-        DELETE_MUTATION_RESPONSE_TYPE_NAME,
-        PUBLICATION_STATUS_TYPE_NAME,
-        GRAPHQL_SCALARS,
-        STRAPI_SCALARS,
-        GENERIC_MORPH_TYPENAME,
-        KINDS,
-        GRAPHQL_SCALAR_OPERATORS,
-        SCALARS_ASSOCIATIONS,
-        ERROR_CODES,
-        ERROR_TYPE_NAME
-    }));
-
-const SortArg = nexus.arg({
-    type: nexus.list('String'),
-    default: []
-});
-
-var publicationStatus$1 = (({ strapi })=>{
-    const { PUBLICATION_STATUS_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-    return nexus.arg({
-        type: PUBLICATION_STATUS_TYPE_NAME,
-        default: 'published'
-    });
-});
-
-const PaginationInputType = nexus.inputObjectType({
-    name: 'PaginationArg',
-    definition (t) {
-        t.int('page');
-        t.int('pageSize');
-        t.int('start');
-        t.int('limit');
-    }
-});
-var PaginationArg = nexus.arg({
-    type: PaginationInputType,
-    default: {}
-});
-
-var args = ((context)=>({
-        SortArg,
-        PaginationArg,
-        PublicationStatusArg: publicationStatus$1(context)
-    }));
-
-const { ValidationError: ValidationError$2 } = utils$2.errors;
-/**
- * A GraphQL scalar used to store Time (HH:mm:ss.SSS) values
- * @type {GraphQLScalarType}
- */ const TimeScalar = new graphql.GraphQLScalarType({
-    name: 'Time',
-    description: 'A time string with format HH:mm:ss.SSS',
-    serialize (value) {
-        return utils$2.parseType({
-            type: 'time',
-            value
-        });
-    },
-    parseValue (value) {
-        return utils$2.parseType({
-            type: 'time',
-            value
-        });
-    },
-    parseLiteral (ast) {
-        if (ast.kind !== graphql.Kind.STRING) {
-            throw new ValidationError$2('Time cannot represent non string type');
-        }
-        const { value } = ast;
-        return utils$2.parseType({
-            type: 'time',
-            value
-        });
-    }
-});
-
-const parseAndCast = (parseFn)=>(...args)=>{
-        const parsedValue = parseFn(...args);
-        if (parsedValue instanceof Date) {
-            return parsedValue.toISOString().split('T')[0];
-        }
-        return parsedValue;
-    };
-// GraphQLDate casts the date string to new Date, we want to keep it as a string so we cast it back to a string
-// see https://github.com/excitement-engineer/graphql-iso-date/issues/106
-graphqlScalars.GraphQLDate.parseValue = parseAndCast(graphqlScalars.GraphQLDate.parseValue);
-graphqlScalars.GraphQLDate.parseLiteral = parseAndCast(graphqlScalars.GraphQLDate.parseLiteral);
-
-var scalars = (()=>({
-        JSON: nexus.asNexusMethod(graphqlScalars.GraphQLJSON, 'json'),
-        DateTime: nexus.asNexusMethod(graphqlScalars.GraphQLDateTime, 'dateTime'),
-        Time: nexus.asNexusMethod(TimeScalar, 'time'),
-        Date: nexus.asNexusMethod(graphqlScalars.GraphQLDate, 'date'),
-        Long: nexus.asNexusMethod(graphqlScalars.GraphQLLong, 'long')
-    }));
-
-var pagination = (({ strapi })=>{
-    const { PAGINATION_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-    return {
-        /**
-     * Type definition for a Pagination object
-     * @type {NexusObjectTypeDef}
-     */ Pagination: nexus.objectType({
-            name: PAGINATION_TYPE_NAME,
-            definition (t) {
-                t.nonNull.int('total');
-                t.nonNull.int('page');
-                t.nonNull.int('pageSize');
-                t.nonNull.int('pageCount');
-            }
-        })
-    };
-});
-
-var buildResponseCollectionMeta = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    const { RESPONSE_COLLECTION_META_TYPE_NAME, PAGINATION_TYPE_NAME } = getService('constants');
-    return {
-        /**
-     * A shared type definition used in EntitiesResponseCollection
-     * to have information about the collection as a whole
-     * @type {NexusObjectTypeDef}
-     */ ResponseCollectionMeta: nexus.objectType({
-            name: RESPONSE_COLLECTION_META_TYPE_NAME,
-            definition (t) {
-                const { resolvePagination } = getService('builders').get('content-api');
-                t.nonNull.field('pagination', {
-                    type: PAGINATION_TYPE_NAME,
-                    resolve: resolvePagination
-                });
-            }
-        })
-    };
-});
-
-var buildDeleteMutationResponse = (({ strapi })=>{
-    const { DELETE_MUTATION_RESPONSE_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-    return {
-        DeleteMutationResponse: nexus.objectType({
-            name: DELETE_MUTATION_RESPONSE_TYPE_NAME,
-            definition (t) {
-                t.nonNull.id('documentId');
-            }
-        })
-    };
-});
-
-var publicationStatus = (({ strapi })=>{
-    const { PUBLICATION_STATUS_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-    return {
-        /**
-     * An enum type definition representing a publication status
-     * @type {NexusEnumTypeDef}
-     */ PublicationStatus: nexus.enumType({
-            name: PUBLICATION_STATUS_TYPE_NAME,
-            members: {
-                DRAFT: 'draft',
-                PUBLISHED: 'published'
-            }
-        })
-    };
-});
-
-/**
- * Build a map of filters type for every GraphQL scalars
- * @return {Object<string, NexusInputTypeDef>}
- */ const buildScalarFilters = ({ strapi })=>{
-    const { naming, mappers } = strapi.plugin('graphql').service('utils');
-    const { helpers } = strapi.plugin('graphql').service('internals');
-    return helpers.getEnabledScalars().reduce((acc, type)=>{
-        const operators = mappers.graphqlScalarToOperators(type);
-        const typeName = naming.getScalarFilterInputTypeName(type);
-        if (!operators || operators.length === 0) {
-            return acc;
-        }
-        return {
-            ...acc,
-            [typeName]: nexus.inputObjectType({
-                name: typeName,
-                definition (t) {
-                    for (const operator of operators){
-                        operator.add(t, type);
-                    }
-                }
-            })
-        };
-    }, {});
-};
-var filters$1 = ((context)=>({
-        scalars: buildScalarFilters(context)
-    }));
-
-const { ValidationError: ValidationError$1 } = utils$2.errors;
-/**
- * Build an Error object type
- * @return {Object<string, NexusObjectTypeDef>}
- */ var error = (({ strapi })=>{
-    const { ERROR_CODES, ERROR_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-    return nexus.objectType({
-        name: ERROR_TYPE_NAME,
-        definition (t) {
-            t.nonNull.string('code', {
-                resolve (parent) {
-                    const code = fp.get('code', parent);
-                    const isValidPlaceholderCode = Object.values(ERROR_CODES).includes(code);
-                    if (!isValidPlaceholderCode) {
-                        throw new ValidationError$1(`"${code}" is not a valid code value`);
-                    }
-                    return code;
-                }
-            });
-            t.string('message');
-        }
-    });
-});
-
-var types = ((context)=>()=>{
-        const { strapi } = context;
-        const { KINDS } = strapi.plugin('graphql').service('constants');
-        return {
-            [KINDS.internal]: {
-                error: error(context),
-                pagination: pagination(context),
-                responseCollectionMeta: buildResponseCollectionMeta(context),
-                deleteDocumentResponse: buildDeleteMutationResponse(context)
-            },
-            [KINDS.enum]: {
-                publicationStatus: publicationStatus(context)
-            },
-            [KINDS.filtersInput]: {
-                ...filters$1(context)
-            }
-        };
-    });
-
-var getEnabledScalars = (({ strapi })=>()=>{
-        const { GRAPHQL_SCALAR_OPERATORS } = strapi.plugin('graphql').service('constants');
-        return Object.entries(GRAPHQL_SCALAR_OPERATORS)// To be valid, a GraphQL scalar must have at least one operator enabled
-        .filter(([, value])=>value.length > 0)// Only keep the key (the scalar name)
-        .map(fp.first);
-    });
-
-var helpers = ((context)=>({
-        getEnabledScalars: getEnabledScalars(context)
-    }));
-
-var internals = ((context)=>({
-        args: args(context),
-        scalars: scalars(),
-        buildInternalTypes: types(context),
-        helpers: helpers(context)
-    }));
-
-/**
- * Build a Nexus enum type from a Strapi enum attribute
- * @param {object} definition - The definition of the enum
- * @param {string[]} definition.enum - The params of the enum
- * @param {string} name - The name of the enum
- * @return {NexusEnumTypeDef}
- */ const buildEnumTypeDefinition = (definition, name)=>{
-    return nexus.enumType({
-        name,
-        members: definition.enum.reduce((acc, value)=>fp.set(utils$2.strings.toRegressedEnumValue(value), value, acc), {})
-    });
-};
-var enums = (()=>({
-        buildEnumTypeDefinition
-    }));
-
-const { ApplicationError: ApplicationError$1 } = utils$2.errors;
-var dynamicZone = (({ strapi })=>{
-    const buildTypeDefinition = (name, components)=>{
-        const { ERROR_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-        const isEmpty = components.length === 0;
-        const componentsTypeNames = components.map((componentUID)=>{
-            const component = strapi.components[componentUID];
-            if (!component) {
-                throw new ApplicationError$1(`Trying to create a dynamic zone type with an unknown component: "${componentUID}"`);
-            }
-            return component.globalId;
-        });
-        return nexus.unionType({
-            name,
-            resolveType (obj) {
-                if (isEmpty) {
-                    return ERROR_TYPE_NAME;
-                }
-                return strapi.components[obj.__component].globalId;
-            },
-            definition (t) {
-                t.members(...componentsTypeNames, ERROR_TYPE_NAME);
-            }
-        });
-    };
-    const buildInputDefinition = (name, components)=>{
-        const parseData = (value)=>{
-            const component = Object.values(strapi.components).find((component)=>component.globalId === value.__typename);
-            if (!component) {
-                throw new ApplicationError$1(`Component not found. expected one of: ${components.map((uid)=>strapi.components[uid].globalId).join(', ')}`);
-            }
-            return {
-                __component: component.uid,
-                ...fp.omit([
-                    '__typename'
-                ], value)
-            };
-        };
-        return nexus.scalarType({
-            name,
-            serialize: (value)=>value,
-            parseValue: (value)=>parseData(value),
-            parseLiteral (ast, variables) {
-                if (ast.kind !== graphql.Kind.OBJECT) {
-                    return undefined;
-                }
-                const value = graphql.valueFromASTUntyped(ast, variables);
-                return parseData(value);
-            }
-        });
-    };
-    return {
-        /**
-     * Build a Nexus dynamic zone type from a Strapi dz attribute
-     */ buildDynamicZoneDefinition (definition, name, inputName) {
-            const { components } = definition;
-            const typeDefinition = buildTypeDefinition(name, components);
-            const inputDefinition = buildInputDefinition(inputName, components);
-            return [
-                typeDefinition,
-                inputDefinition
-            ];
-        }
-    };
-});
-
-var entity = (({ strapi })=>{
-    const { naming } = strapi.plugin('graphql').service('utils');
-    return {
-        /**
-     * Build a higher level type for a content type which contains the attributes, the ID and the metadata
-     * @param {object} contentType The content type which will be used to build its entity type
-     * @return {NexusObjectTypeDef}
-     */ buildEntityDefinition (contentType) {
-            const { attributes } = contentType;
-            const name = naming.getEntityName(contentType);
-            const typeName = naming.getTypeName(contentType);
-            return nexus.objectType({
-                name,
-                definition (t) {
-                    // Keep the ID attribute at the top level
-                    t.id('id', {
-                        resolve: fp.prop('id')
-                    });
-                    if (!fp.isEmpty(attributes)) {
-                        // Keep the fetched object into a dedicated `attributes` field
-                        t.field('attributes', {
-                            type: typeName,
-                            resolve: fp.identity
-                        });
-                    }
-                }
-            });
-        }
-    };
-});
-
-var typeBuilder = ((context)=>{
-    const { strapi } = context;
-    const getGraphQLService = strapi.plugin('graphql').service;
-    const extension = getGraphQLService('extension');
-    /**
-   * Add a scalar attribute to the type definition
-   *
-   * The attribute is added based on a simple association between a Strapi
-   * type and a GraphQL type (the map is defined in `strapiTypeToGraphQLScalar`)
-   */ const addScalarAttribute = (options)=>{
-        const { builder, attributeName, attribute } = options;
-        const { mappers } = getGraphQLService('utils');
-        const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
-        builder.field(attributeName, {
-            type: gqlType
-        });
-    };
-    /**
-   * Add a component attribute to the type definition
-   *
-   * The attribute is added by fetching the component's type
-   * name and using it as the attribute's type
-   */ const addComponentAttribute = (options)=>{
-        const { builder, attributeName, contentType, attribute } = options;
-        let localBuilder = builder;
-        const { naming } = getGraphQLService('utils');
-        const { getContentTypeArgs } = getGraphQLService('builders').utils;
-        const { buildComponentResolver } = getGraphQLService('builders').get('content-api');
-        const type = naming.getComponentNameFromAttribute(attribute);
-        if (attribute.repeatable) {
-            localBuilder = localBuilder.list;
-        }
-        const targetComponent = strapi.getModel(attribute.component);
-        const resolve = buildComponentResolver({
-            contentTypeUID: contentType.uid,
-            attributeName,
-            strapi
-        });
-        const args = getContentTypeArgs(targetComponent, {
-            multiple: !!attribute.repeatable,
-            isNested: true
-        });
-        localBuilder.field(attributeName, {
-            type,
-            resolve,
-            args
-        });
-    };
-    /**
-   * Add a dynamic zone attribute to the type definition
-   *
-   * The attribute is added by fetching the dynamic zone's
-   * type name and using it as the attribute's type
-   */ const addDynamicZoneAttribute = (options)=>{
-        const { builder, attributeName, contentType } = options;
-        const { naming } = getGraphQLService('utils');
-        const { ERROR_CODES } = getGraphQLService('constants');
-        const { buildDynamicZoneResolver } = getGraphQLService('builders').get('content-api');
-        const { components } = contentType.attributes[attributeName];
-        const isEmpty = components.length === 0;
-        const type = naming.getDynamicZoneName(contentType, attributeName);
-        const resolve = isEmpty ? fp.constant({
-            code: ERROR_CODES.emptyDynamicZone,
-            message: `This dynamic zone don't have any component attached to it`
-        }) : buildDynamicZoneResolver({
-            contentTypeUID: contentType.uid,
-            attributeName
-        });
-        builder.list.field(attributeName, {
-            type,
-            resolve
-        });
-    };
-    /**
-   * Add an enum attribute to the type definition
-   *
-   * The attribute is added by fetching the enum's type
-   * name and using it as the attribute's type
-   */ const addEnumAttribute = (options)=>{
-        const { builder, attributeName, contentType } = options;
-        const { naming } = getGraphQLService('utils');
-        const type = naming.getEnumName(contentType, attributeName);
-        builder.field(attributeName, {
-            type
-        });
-    };
-    /**
-   * Add a media attribute to the type definition
-   */ const addMediaAttribute = (options)=>{
-        const { naming } = getGraphQLService('utils');
-        const { getContentTypeArgs } = getGraphQLService('builders').utils;
-        const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
-        const extension = getGraphQLService('extension');
-        const { builder } = options;
-        const { attributeName, attribute, contentType } = options;
-        const fileUID = 'plugin::upload.file';
-        if (extension.shadowCRUD(fileUID).isDisabled()) {
-            return;
-        }
-        const fileContentType = strapi.contentTypes[fileUID];
-        const resolve = buildAssociationResolver({
-            contentTypeUID: contentType.uid,
-            attributeName,
-            strapi
-        });
-        const args = attribute.multiple ? getContentTypeArgs(fileContentType, {
-            isNested: true
-        }) : undefined;
-        const typeName = naming.getTypeName(fileContentType);
-        if (attribute.multiple) {
-            builder.field(`${attributeName}_connection`, {
-                type: naming.getRelationResponseCollectionName(fileContentType),
-                resolve,
-                args
-            });
-            builder.field(attributeName, {
-                type: nexus.nonNull(nexus.list(typeName)),
-                async resolve (...args) {
-                    const res = await resolve(...args);
-                    return res.nodes ?? [];
-                },
-                args
-            });
-        } else {
-            builder.field(attributeName, {
-                type: typeName,
-                async resolve (...args) {
-                    const res = await resolve(...args);
-                    return res.value;
-                },
-                args
-            });
-        }
-    };
-    /**
-   * Add a polymorphic relational attribute to the type definition
-   */ const addPolymorphicRelationalAttribute = (options)=>{
-        const { GENERIC_MORPH_TYPENAME } = getGraphQLService('constants');
-        const { naming } = getGraphQLService('utils');
-        const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
-        let { builder } = options;
-        const { attributeName, attribute, contentType } = options;
-        const { target } = attribute;
-        const isToManyRelation = attribute.relation.endsWith('Many');
-        if (isToManyRelation) {
-            builder = builder.list;
-        }
-        // todo[v4]: How to handle polymorphic relation w/ entity response collection types?
-        //  -> Currently return raw polymorphic entities
-        const resolve = buildAssociationResolver({
-            contentTypeUID: contentType.uid,
-            attributeName,
-            strapi
-        });
-        // If there is no specific target specified, then use the GenericMorph type
-        if (fp.isUndefined(target)) {
-            builder.field(attributeName, {
-                type: GENERIC_MORPH_TYPENAME,
-                resolve
-            });
-        } else if (fp.isArray(target) && target.every(fp.isString)) {
-            const type = naming.getMorphRelationTypeName(contentType, attributeName);
-            builder.field(attributeName, {
-                type,
-                resolve
-            });
-        }
-    };
-    /**
-   * Add a regular relational attribute to the type definition
-   */ const addRegularRelationalAttribute = (options)=>{
-        const { naming } = getGraphQLService('utils');
-        const { getContentTypeArgs } = getGraphQLService('builders').utils;
-        const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
-        const extension = getGraphQLService('extension');
-        const { builder } = options;
-        const { attributeName, attribute, contentType } = options;
-        if (extension.shadowCRUD(attribute.target).isDisabled()) {
-            return;
-        }
-        const isToManyRelation = attribute.relation.endsWith('Many');
-        const resolve = buildAssociationResolver({
-            contentTypeUID: contentType.uid,
-            attributeName,
-            strapi
-        });
-        const targetContentType = strapi.getModel(attribute.target);
-        const typeName = naming.getTypeName(targetContentType);
-        const args = isToManyRelation ? getContentTypeArgs(targetContentType, {
-            isNested: true
-        }) : undefined;
-        const resolverScope = `${targetContentType.uid}.find`;
-        const resolverPath = `${naming.getTypeName(contentType)}.${attributeName}`;
-        extension.use({
-            resolversConfig: {
-                [resolverPath]: {
-                    auth: {
-                        scope: [
-                            resolverScope
-                        ]
-                    }
-                }
-            }
-        });
-        if (isToManyRelation) {
-            builder.field(`${attributeName}_connection`, {
-                type: naming.getRelationResponseCollectionName(targetContentType),
-                resolve,
-                args
-            });
-            extension.use({
-                resolversConfig: {
-                    [`${resolverPath}_connection`]: {
-                        auth: {
-                            scope: [
-                                resolverScope
-                            ]
-                        }
-                    }
-                }
-            });
-            builder.field(attributeName, {
-                type: nexus.nonNull(nexus.list(typeName)),
-                async resolve (...args) {
-                    const res = await resolve(...args);
-                    return res.nodes ?? [];
-                },
-                args
-            });
-        } else {
-            builder.field(attributeName, {
-                type: typeName,
-                async resolve (...args) {
-                    const res = await resolve(...args);
-                    return res.value;
-                },
-                args
-            });
-        }
-    };
-    const isNotPrivate = (contentType)=>(attributeName)=>{
-            return !utils$2.contentTypes.isPrivateAttribute(contentType, attributeName);
-        };
-    const isNotDisabled = (contentType)=>(attributeName)=>{
-            return extension.shadowCRUD(contentType.uid).field(attributeName).hasOutputEnabled();
-        };
-    return {
-        /**
-     * Create a type definition for a given content type
-     * @param contentType - The content type used to created the definition
-     * @return {NexusObjectTypeDef}
-     */ buildTypeDefinition (contentType) {
-            const utils = getGraphQLService('utils');
-            const { getComponentName, getTypeName } = utils.naming;
-            const { isStrapiScalar, isComponent, isDynamicZone, isEnumeration, isMedia, isMorphRelation, isRelation } = utils.attributes;
-            const { attributes, modelType } = contentType;
-            const attributesKey = Object.keys(attributes);
-            const name = (modelType === 'component' ? getComponentName : getTypeName).call(null, contentType);
-            return nexus.objectType({
-                name,
-                definition (t) {
-                    // add back the old id attribute on contentType if v4 compat is enabled
-                    if (modelType !== 'component' && isNotDisabled(contentType)('id') && strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
-                        t.nonNull.id('id', {
-                            deprecation: 'Use `documentId` instead'
-                        });
-                    }
-                    if (modelType === 'component' && isNotDisabled(contentType)('id')) {
-                        t.nonNull.id('id');
-                    }
-                    if (modelType !== 'component' && isNotDisabled(contentType)('documentId')) {
-                        t.nonNull.id('documentId');
-                    }
-                    if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
-                        t.nonNull.field('attributes', {
-                            deprecation: 'Use root level fields instead',
-                            type: name,
-                            resolve: (parent)=>parent
-                        });
-                        t.nonNull.field('data', {
-                            deprecation: 'Use root level fields instead',
-                            type: name,
-                            resolve: (parent)=>parent
-                        });
-                    }
-                    /** Attributes
-           *
-           * Attributes can be of 7 different kind:
-           * - Scalar
-           * - Component
-           * - Dynamic Zone
-           * - Enum
-           * - Media
-           * - Polymorphic Relations
-           * - Regular Relations
-           *
-           * Here, we iterate over each non-private attribute
-           * and add it to the type definition based on its type
-           */ attributesKey// Ignore private attributes
-                    .filter(isNotPrivate(contentType))// Ignore disabled fields (from extension service)
-                    .filter(isNotDisabled(contentType))// Add each attribute to the type definition
-                    .forEach((attributeName)=>{
-                        const attribute = attributes[attributeName];
-                        // We create a copy of the builder (t) to apply custom
-                        // rules only on the current attribute (eg: nonNull, list, ...)
-                        let builder = t;
-                        if (attribute.required) {
-                            builder = builder.nonNull;
-                        }
-                        const options = {
-                            builder,
-                            attributeName,
-                            attribute,
-                            contentType,
-                            context
-                        };
-                        // Enums
-                        if (isEnumeration(attribute)) {
-                            addEnumAttribute(options);
-                        } else if (isStrapiScalar(attribute)) {
-                            addScalarAttribute(options);
-                        } else if (isComponent(attribute)) {
-                            addComponentAttribute(options);
-                        } else if (isDynamicZone(attribute)) {
-                            addDynamicZoneAttribute(options);
-                        } else if (isMedia(attribute)) {
-                            addMediaAttribute(options);
-                        } else if (isMorphRelation(attribute)) {
-                            addPolymorphicRelationalAttribute(options);
-                        } else if (isRelation(attribute)) {
-                            addRegularRelationalAttribute(options);
-                        }
-                    });
-                }
-            });
-        }
-    };
-});
-
-var response = (({ strapi })=>{
-    const { naming } = strapi.plugin('graphql').service('utils');
-    return {
-        /**
-     * Build a type definition for a content API response for a given content type
-     */ buildResponseDefinition (contentType) {
-            const name = naming.getEntityResponseName(contentType);
-            const typeName = naming.getTypeName(contentType);
-            return nexus.objectType({
-                name,
-                definition (t) {
-                    t.field('data', {
-                        type: typeName,
-                        resolve: fp.prop('value')
-                    });
-                }
-            });
-        }
-    };
-});
-
-var responseCollection = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    const { naming } = getService('utils');
-    const { RESPONSE_COLLECTION_META_TYPE_NAME, PAGINATION_TYPE_NAME } = getService('constants');
-    return {
-        /**
-     * Build a type definition for a content API collection response for a given content type
-     * @param {Schema.ContentType} contentType The content type which will be used to build its content API response definition
-     * @return {NexusObjectTypeDef}
-     */ buildResponseCollectionDefinition (contentType) {
-            const name = naming.getEntityResponseCollectionName(contentType);
-            const typeName = naming.getTypeName(contentType);
-            const { resolvePagination } = getService('builders').get('content-api');
-            return nexus.objectType({
-                name,
-                definition (t) {
-                    // NOTE: add edges & cursor based pagination to support the relay spec in a later version
-                    t.nonNull.list.field('nodes', {
-                        type: nexus.nonNull(typeName),
-                        resolve: fp.pipe(fp.prop('nodes'), fp.defaultTo([]))
-                    });
-                    t.nonNull.field('pageInfo', {
-                        type: PAGINATION_TYPE_NAME,
-                        resolve: resolvePagination
-                    });
-                    if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
-                        t.nonNull.list.field('data', {
-                            deprecation: 'Use `nodes` field instead',
-                            type: nexus.nonNull(typeName),
-                            resolve: fp.pipe(fp.prop('nodes'), fp.defaultTo([]))
-                        });
-                        t.nonNull.field('meta', {
-                            deprecation: 'Use the `pageInfo` field instead',
-                            type: RESPONSE_COLLECTION_META_TYPE_NAME,
-                            resolve: fp.identity
-                        });
-                    }
-                }
-            });
-        }
-    };
-});
-
-var relationResponseCollection = (({ strapi })=>{
-    const { naming } = strapi.plugin('graphql').service('utils');
-    return {
-        /**
-     * Build a type definition for a content API relation's collection response for a given content type
-     */ buildRelationResponseCollectionDefinition (contentType) {
-            const name = naming.getRelationResponseCollectionName(contentType);
-            const typeName = naming.getTypeName(contentType);
-            return nexus.objectType({
-                name,
-                definition (t) {
-                    t.nonNull.list.field('nodes', {
-                        type: nexus.nonNull(typeName),
-                        resolve: fp.pipe(fp.prop('nodes'), fp.defaultTo([]))
-                    });
-                    if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
-                        t.nonNull.list.field('data', {
-                            deprecation: 'Use `nodes` field instead',
-                            type: nexus.nonNull(typeName),
-                            resolve: fp.pipe(fp.prop('nodes'), fp.defaultTo([]))
-                        });
-                    }
-                }
-            });
-        }
-    };
-});
-
-var createCollectionTypeQueriesBuilder = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    const { naming } = getService('utils');
-    const { transformArgs, getContentTypeArgs } = getService('builders').utils;
-    const { toEntityResponseCollection } = getService('format').returnTypes;
-    const { getFindOneQueryName, getTypeName, getFindQueryName, getFindConnectionQueryName, getEntityResponseCollectionName } = naming;
-    const buildCollectionTypeQueries = (contentType)=>{
-        const findOneQueryName = `Query.${getFindOneQueryName(contentType)}`;
-        const findQueryName = `Query.${getFindQueryName(contentType)}`;
-        const findConnectionQueryName = `Query.${getFindConnectionQueryName(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 isFindOneEnabled = isActionEnabled('findOne');
-        const isFindEnabled = isActionEnabled('find');
-        if (isFindOneEnabled) {
-            registerAuthConfig(findOneQueryName, {
-                scope: [
-                    `${contentType.uid}.findOne`
-                ]
-            });
-        }
-        if (isFindEnabled) {
-            registerAuthConfig(findQueryName, {
-                scope: [
-                    `${contentType.uid}.find`
-                ]
-            });
-            registerAuthConfig(findConnectionQueryName, {
-                scope: [
-                    `${contentType.uid}.find`
-                ]
-            });
-        }
-        return nexus.extendType({
-            type: 'Query',
-            definition (t) {
-                if (isFindOneEnabled) {
-                    addFindOneQuery(t, contentType);
-                }
-                if (isFindEnabled) {
-                    addFindConnectionQuery(t, contentType);
-                    addFindQuery(t, contentType);
-                }
-            }
-        });
-    };
-    /**
-   * Register a "find one" query field to the nexus type definition
-   */ const addFindOneQuery = (t, contentType)=>{
-        const findOneQueryName = getFindOneQueryName(contentType);
-        const typeName = getTypeName(contentType);
-        t.field(findOneQueryName, {
-            type: typeName,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: getContentTypeArgs(contentType, {
-                multiple: false
-            }),
-            async resolve (parent, args, ctx) {
-                const transformedArgs = transformArgs(args, {
-                    contentType
-                });
-                const { findOne } = getService('builders').get('content-api').buildQueriesResolvers({
-                    contentType
-                });
-                // queryResolvers will sanitize params
-                return findOne(parent, transformedArgs, ctx);
-            }
-        });
-    };
-    /**
-   * Register a "find" query field to the nexus type definition
-   */ const addFindQuery = (t, contentType)=>{
-        const findQueryName = getFindQueryName(contentType);
-        const typeName = getTypeName(contentType);
-        t.field(findQueryName, {
-            type: nexus.nonNull(nexus.list(typeName)),
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: getContentTypeArgs(contentType),
-            async resolve (parent, args, ctx) {
-                const transformedArgs = transformArgs(args, {
-                    contentType,
-                    usePagination: true
-                });
-                const { findMany } = getService('builders').get('content-api').buildQueriesResolvers({
-                    contentType
-                });
-                // queryResolvers will sanitize params
-                return findMany(parent, transformedArgs, ctx);
-            }
-        });
-    };
-    /**
-   * Register a "find" query field to the nexus type definition
-   */ const addFindConnectionQuery = (t, contentType)=>{
-        const { uid } = contentType;
-        const queryName = getFindConnectionQueryName(contentType);
-        const responseCollectionTypeName = getEntityResponseCollectionName(contentType);
-        t.field(queryName, {
-            type: responseCollectionTypeName,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: getContentTypeArgs(contentType),
-            async resolve (parent, args, ctx) {
-                const transformedArgs = transformArgs(args, {
-                    contentType,
-                    usePagination: true
-                });
-                const { findMany } = getService('builders').get('content-api').buildQueriesResolvers({
-                    contentType
-                });
-                // queryResolvers will sanitize params
-                const nodes = await findMany(parent, transformedArgs, ctx);
-                return toEntityResponseCollection(nodes, {
-                    args: transformedArgs,
-                    resourceUID: uid
-                });
-            }
-        });
-    };
-    return {
-        buildCollectionTypeQueries
-    };
-});
-
-var createSingleTypeQueriesBuilder = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    const { naming } = getService('utils');
-    const { transformArgs, getContentTypeArgs } = getService('builders').utils;
-    const { getFindOneQueryName, getTypeName } = naming;
-    const buildSingleTypeQueries = (contentType)=>{
-        const findQueryName = `Query.${getFindOneQueryName(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 isFindEnabled = isActionEnabled('find');
-        if (isFindEnabled) {
-            registerAuthConfig(findQueryName, {
-                scope: [
-                    `${contentType.uid}.find`
-                ]
-            });
-        }
-        return nexus.extendType({
-            type: 'Query',
-            definition (t) {
-                if (isFindEnabled) {
-                    addFindQuery(t, contentType);
-                }
-            }
-        });
-    };
-    const addFindQuery = (t, contentType)=>{
-        const findQueryName = getFindOneQueryName(contentType);
-        const typeName = getTypeName(contentType);
-        t.field(findQueryName, {
-            type: typeName,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: getContentTypeArgs(contentType),
-            async resolve (parent, args, ctx) {
-                const transformedArgs = transformArgs(args, {
-                    contentType
-                });
-                const { findFirst } = getService('builders').get('content-api').buildQueriesResolvers({
-                    contentType
-                });
-                return findFirst(parent, transformedArgs, ctx);
-            }
-        });
-    };
-    return {
-        buildSingleTypeQueries
-    };
-});
-
-var queries = ((context)=>({
-        ...createCollectionTypeQueriesBuilder(context),
-        ...createSingleTypeQueriesBuilder(context)
-    }));
-
-var createCollectionTypeMutationsBuilder = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    const { naming } = getService('utils');
-    const { args } = getService('internals');
-    const { getCreateMutationTypeName, getUpdateMutationTypeName, getDeleteMutationTypeName, getContentTypeInputName, getTypeName } = naming;
-    const addCreateMutation = (t, contentType)=>{
-        const { uid } = contentType;
-        const createMutationName = getCreateMutationTypeName(contentType);
-        const typeName = getTypeName(contentType);
-        t.field(createMutationName, {
-            type: typeName,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: {
-                // Create payload
-                status: args.PublicationStatusArg,
-                data: nexus.nonNull(getContentTypeInputName(contentType))
-            },
-            async resolve (parent, args, context) {
-                const { auth } = context.state;
-                // Sanitize input data
-                const sanitizedInputData = await strapi.contentAPI.sanitize.input(args.data, contentType, {
-                    auth
-                });
-                return strapi.documents(uid).create({
-                    ...args,
-                    data: sanitizedInputData
-                });
-            }
-        });
-    };
-    const addUpdateMutation = (t, contentType)=>{
-        const { uid } = contentType;
-        const updateMutationName = getUpdateMutationTypeName(contentType);
-        const typeName = getTypeName(contentType);
-        t.field(updateMutationName, {
-            type: typeName,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: {
-                documentId: nexus.nonNull(nexus.idArg()),
-                status: args.PublicationStatusArg,
-                data: nexus.nonNull(getContentTypeInputName(contentType))
-            },
-            async resolve (parent, args, context) {
-                const { auth } = context.state;
-                const { data, ...restParams } = args;
-                // Sanitize input data
-                const sanitizedInputData = await strapi.contentAPI.sanitize.input(data, contentType, {
-                    auth
-                });
-                return strapi.documents(uid).update({
-                    ...restParams,
-                    data: sanitizedInputData
-                });
-            }
-        });
-    };
-    const addDeleteMutation = (t, contentType)=>{
-        const { uid } = contentType;
-        const deleteMutationName = getDeleteMutationTypeName(contentType);
-        const { DELETE_MUTATION_RESPONSE_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-        t.field(deleteMutationName, {
-            type: DELETE_MUTATION_RESPONSE_TYPE_NAME,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: {
-                documentId: nexus.nonNull(nexus.idArg())
-            },
-            async resolve (parent, args) {
-                const { documentId } = args;
-                await strapi.documents(uid).delete({
-                    documentId
-                });
-                return {
-                    documentId
-                };
-            }
-        });
-    };
-    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 nexus.extendType({
-                type: 'Mutation',
-                definition (t) {
-                    if (isCreateEnabled) {
-                        addCreateMutation(t, contentType);
-                    }
-                    if (isUpdateEnabled) {
-                        addUpdateMutation(t, contentType);
-                    }
-                    if (isDeleteEnabled) {
-                        addDeleteMutation(t, contentType);
-                    }
-                }
-            });
-        }
-    };
-});
-
-const { NotFoundError } = utils$2.errors;
-var createSingleTypeMutationsBuilder = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    const { naming } = getService('utils');
-    const { args } = getService('internals');
-    const { getUpdateMutationTypeName, getTypeName, getContentTypeInputName, getDeleteMutationTypeName } = naming;
-    const addUpdateMutation = (t, contentType)=>{
-        const { uid } = contentType;
-        const updateMutationName = getUpdateMutationTypeName(contentType);
-        const typeName = getTypeName(contentType);
-        t.field(updateMutationName, {
-            type: typeName,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: {
-                // Update payload
-                status: args.PublicationStatusArg,
-                data: nexus.nonNull(getContentTypeInputName(contentType))
-            },
-            async resolve (parent, args, context) {
-                const { auth } = context.state;
-                // Sanitize input data
-                const sanitizedInputData = await strapi.contentAPI.sanitize.input(args.data, contentType, {
-                    auth
-                });
-                const document = await strapi.db?.query(uid).findOne();
-                if (document) {
-                    return strapi.documents(uid).update({
-                        ...args,
-                        documentId: document.documentId,
-                        data: sanitizedInputData
-                    });
-                }
-                return strapi.documents(uid).create({
-                    ...args,
-                    data: sanitizedInputData
-                });
-            }
-        });
-    };
-    const addDeleteMutation = (t, contentType)=>{
-        const { uid } = contentType;
-        const deleteMutationName = getDeleteMutationTypeName(contentType);
-        const { DELETE_MUTATION_RESPONSE_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-        t.field(deleteMutationName, {
-            type: DELETE_MUTATION_RESPONSE_TYPE_NAME,
-            extensions: {
-                strapi: {
-                    contentType
-                }
-            },
-            args: {},
-            async resolve (parent, args) {
-                const document = await strapi.db?.query(uid).findOne();
-                if (!document) {
-                    throw new NotFoundError('Document not found');
-                }
-                await strapi.documents(uid).delete({
-                    ...args,
-                    documentId: document.documentId
-                });
-                return document;
-            }
-        });
-    };
-    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 nexus.extendType({
-                type: 'Mutation',
-                definition (t) {
-                    if (isUpdateEnabled) {
-                        addUpdateMutation(t, contentType);
-                    }
-                    if (isDeleteEnabled) {
-                        addDeleteMutation(t, contentType);
-                    }
-                }
-            });
-        }
-    };
-});
-
-var mutations = ((context)=>({
-        ...createCollectionTypeMutationsBuilder(context),
-        ...createSingleTypeMutationsBuilder(context)
-    }));
-
-var contentType = (({ strapi })=>{
-    const rootLevelOperators = ()=>{
-        const { operators } = strapi.plugin('graphql').service('builders').filters;
-        return [
-            operators.and,
-            operators.or,
-            operators.not
-        ];
-    };
-    const addScalarAttribute = (builder, attributeName, attribute)=>{
-        const { naming, mappers } = strapi.plugin('graphql').service('utils');
-        const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
-        builder.field(attributeName, {
-            type: naming.getScalarFilterInputTypeName(gqlType)
-        });
-    };
-    const addRelationalAttribute = (builder, attributeName, attribute)=>{
-        const utils = strapi.plugin('graphql').service('utils');
-        const extension = strapi.plugin('graphql').service('extension');
-        const { getFiltersInputTypeName } = utils.naming;
-        const { isMorphRelation } = utils.attributes;
-        const model = 'target' in attribute && strapi.getModel(attribute.target);
-        // If there is no model corresponding to the attribute configuration
-        // or if the attribute is a polymorphic relation, then ignore it
-        if (!model || isMorphRelation(attribute)) return;
-        // If the target model is disabled, then ignore it too
-        if (extension.shadowCRUD(model.uid).isDisabled()) return;
-        builder.field(attributeName, {
-            type: getFiltersInputTypeName(model)
-        });
-    };
-    const addComponentAttribute = (builder, attributeName, attribute)=>{
-        const utils = strapi.plugin('graphql').service('utils');
-        const extension = strapi.plugin('graphql').service('extension');
-        const { getFiltersInputTypeName } = utils.naming;
-        const component = strapi.getModel(attribute.component);
-        // If there is no component corresponding to the attribute configuration, then ignore it
-        if (!component) return;
-        // If the component is disabled, then ignore it too
-        if (extension.shadowCRUD(component.uid).isDisabled()) return;
-        builder.field(attributeName, {
-            type: getFiltersInputTypeName(component)
-        });
-    };
-    const buildContentTypeFilters = (contentType)=>{
-        const utils = strapi.plugin('graphql').service('utils');
-        const extension = strapi.plugin('graphql').service('extension');
-        const { getFiltersInputTypeName, getScalarFilterInputTypeName } = utils.naming;
-        const { isStrapiScalar, isRelation, isComponent } = utils.attributes;
-        const { attributes } = contentType;
-        const filtersTypeName = getFiltersInputTypeName(contentType);
-        return nexus.inputObjectType({
-            name: filtersTypeName,
-            definition (t) {
-                const validAttributes = Object.entries(attributes)// Remove private attributes
-                .filter(([attributeName])=>!utils$2.contentTypes.isPrivateAttribute(contentType, attributeName))// Remove attributes that have been disabled using the shadow CRUD extension API
-                .filter(([attributeName])=>extension.shadowCRUD(contentType.uid).field(attributeName).hasFiltersEnabeld());
-                const isIDFilterEnabled = extension.shadowCRUD(contentType.uid).field('documentId').hasFiltersEnabeld();
-                // Add an ID filter to the collection types
-                if (contentType.kind === 'collectionType' && isIDFilterEnabled) {
-                    t.field('documentId', {
-                        type: getScalarFilterInputTypeName('ID')
-                    });
-                }
-                // Add every defined attribute
-                for (const [attributeName, attribute] of validAttributes){
-                    // Handle scalars
-                    if (isStrapiScalar(attribute)) {
-                        addScalarAttribute(t, attributeName, attribute);
-                    } else if (isRelation(attribute)) {
-                        addRelationalAttribute(t, attributeName, attribute);
-                    } else if (isComponent(attribute)) {
-                        addComponentAttribute(t, attributeName, attribute);
-                    }
-                }
-                // Conditional clauses
-                for (const operator of rootLevelOperators()){
-                    operator.add(t, filtersTypeName);
-                }
-            }
-        });
-    };
-    return {
-        buildContentTypeFilters
-    };
-});
-
-var filters = ((context)=>({
-        ...contentType(context)
-    }));
-
-const { isWritableAttribute } = utils$2.contentTypes;
-var inputs = (({ strapi })=>{
-    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 nexus.inputObjectType({
-                name,
-                definition (t) {
-                    const isFieldEnabled = (fieldName)=>{
-                        return extension.shadowCRUD(contentType.uid).field(fieldName).hasInputEnabled();
-                    };
-                    const validAttributes = Object.entries(attributes)// Remove private attributes
-                    .filter(([attributeName])=>!utils$2.contentTypes.isPrivateAttribute(contentType, attributeName))// Remove non-writable attributes
-                    .filter(([attributeName])=>isWritableAttribute(contentType, attributeName))// Remove filters that have been disabled using the shadow CRUD extension API
-                    .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])=>{
-                        // Enums
-                        if (isEnumeration(attribute)) {
-                            const enumTypeName = getEnumName(contentType, attributeName);
-                            t.field(attributeName, {
-                                type: enumTypeName
-                            });
-                        } else if (isStrapiScalar(attribute)) {
-                            const gqlScalar = mappers.strapiScalarToGraphQLScalar(attribute.type);
-                            t.field(attributeName, {
-                                type: gqlScalar
-                            });
-                        } else if (isMedia(attribute)) {
-                            const isMultiple = attribute.multiple === true;
-                            if (extension.shadowCRUD('plugin::upload.file').isDisabled()) {
-                                return;
-                            }
-                            if (isMultiple) {
-                                t.list.id(attributeName);
-                            } else {
-                                t.id(attributeName);
-                            }
-                        } else if (isRelation(attribute) && !isMorphRelation(attribute)) {
-                            if (extension.shadowCRUD(attribute.target).isDisabled()) {
-                                return;
-                            }
-                            const isToManyRelation = attribute.relation.endsWith('Many');
-                            if (isToManyRelation) {
-                                t.list.id(attributeName);
-                            } else {
-                                t.id(attributeName);
-                            }
-                        } 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
-                                });
-                            }
-                        } else if (isDynamicZone(attribute)) {
-                            const dzInputName = getDynamicZoneInputName(contentType, attributeName);
-                            t.list.field(attributeName, {
-                                type: nexus.nonNull(dzInputName)
-                            });
-                        }
-                    });
-                }
-            });
-        }
-    };
-});
-
-var genericMorph = (({ strapi, registry })=>{
-    const { naming } = strapi.plugin('graphql').service('utils');
-    const { KINDS, GENERIC_MORPH_TYPENAME } = strapi.plugin('graphql').service('constants');
-    return {
-        buildGenericMorphDefinition () {
-            return nexus.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(fp.prop('name'));
-                    t.members(...members);
-                }
-            });
-        }
-    };
-});
-
-const { ApplicationError } = utils$2.errors;
-var associationResolvers = (({ strapi })=>{
-    const { service: getGraphQLService } = strapi.plugin('graphql');
-    const { isMorphRelation, isMedia } = getGraphQLService('utils').attributes;
-    const { transformArgs } = getGraphQLService('builders').utils;
-    const { toEntityResponse, toEntityResponseCollection } = getGraphQLService('format').returnTypes;
-    return {
-        buildAssociationResolver ({ contentTypeUID, attributeName }) {
-            const contentType = strapi.getModel(contentTypeUID);
-            const attribute = contentType.attributes[attributeName];
-            if (!attribute) {
-                throw new ApplicationError(`Failed to build an association resolver for ${contentTypeUID}::${attributeName}`);
-            }
-            const isMediaAttribute = isMedia(attribute);
-            const isMorphAttribute = isMorphRelation(attribute);
-            const targetUID = isMediaAttribute ? 'plugin::upload.file' : attribute.target;
-            const isToMany = isMediaAttribute ? attribute.multiple : attribute.relation.endsWith('Many');
-            const targetContentType = strapi.getModel(targetUID);
-            return async (parent, args = {}, context = {})=>{
-                const { auth } = context.state;
-                const transformedArgs = transformArgs(args, {
-                    contentType: targetContentType,
-                    usePagination: true
-                });
-                await strapi.contentAPI.validate.query(transformedArgs, targetContentType, {
-                    auth
-                });
-                const sanitizedQuery = await strapi.contentAPI.sanitize.query(transformedArgs, targetContentType, {
-                    auth
-                });
-                const dbQuery = strapi.get('query-params').transform(targetUID, sanitizedQuery);
-                const data = await strapi.db?.query(contentTypeUID).load(parent, attributeName, dbQuery);
-                const info = {
-                    args: sanitizedQuery,
-                    resourceUID: targetUID
-                };
-                // If this a polymorphic association, it sanitizes & returns the raw data
-                // Note: The value needs to be wrapped in a fake object that represents its parent
-                // so that the sanitize util can work properly.
-                if (isMorphAttribute) {
-                    // Helpers used for the data cleanup
-                    const wrapData = (dataToWrap)=>({
-                            [attributeName]: dataToWrap
-                        });
-                    const sanitizeData = (dataToSanitize)=>{
-                        return strapi.contentAPI.sanitize.output(dataToSanitize, contentType, {
-                            auth
-                        });
-                    };
-                    const unwrapData = fp.get(attributeName);
-                    // Sanitizer definition
-                    const sanitizeMorphAttribute = utils$2.async.pipe(wrapData, sanitizeData, unwrapData);
-                    return sanitizeMorphAttribute(data);
-                }
-                // If this is a to-many relation, it returns an object that
-                // matches what the entity-response-collection's resolvers expect
-                if (isToMany) {
-                    return toEntityResponseCollection(data, info);
-                }
-                // Else, it returns an object that matches
-                // what the entity-response's resolvers expect
-                return toEntityResponse(data, info);
-            };
-        }
-    };
-});
-
-var queriesResolvers = (({ strapi })=>({
-        buildQueriesResolvers ({ contentType }) {
-            const { uid } = contentType;
-            return {
-                async findMany (parent, args, ctx) {
-                    await strapi.contentAPI.validate.query(args, contentType, {
-                        auth: ctx?.state?.auth
-                    });
-                    const sanitizedQuery = await strapi.contentAPI.sanitize.query(args, contentType, {
-                        auth: ctx?.state?.auth
-                    });
-                    return strapi.documents(uid).findMany({
-                        status: 'published',
-                        ...sanitizedQuery
-                    });
-                },
-                async findFirst (parent, args, ctx) {
-                    await strapi.contentAPI.validate.query(args, contentType, {
-                        auth: ctx?.state?.auth
-                    });
-                    const sanitizedQuery = await strapi.contentAPI.sanitize.query(args, contentType, {
-                        auth: ctx?.state?.auth
-                    });
-                    return strapi.documents(uid).findFirst({
-                        status: 'published',
-                        ...sanitizedQuery
-                    });
-                },
-                async findOne (parent, args, ctx) {
-                    const { documentId } = args;
-                    await strapi.contentAPI.validate.query(args, contentType, {
-                        auth: ctx?.state?.auth
-                    });
-                    const sanitizedQuery = await strapi.contentAPI.sanitize.query(args, contentType, {
-                        auth: ctx?.state?.auth
-                    });
-                    return strapi.documents(uid).findOne({
-                        status: 'published',
-                        ...fp.omit([
-                            'id',
-                            'documentId'
-                        ], sanitizedQuery),
-                        documentId
-                    });
-                }
-            };
-        }
-    }));
-
-var componentResolvers = (({ strapi })=>({
-        buildComponentResolver ({ contentTypeUID, attributeName }) {
-            const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
-            return async (parent, args, ctx)=>{
-                const contentType = strapi.getModel(contentTypeUID);
-                const { component: componentName } = contentType.attributes[attributeName];
-                const component = strapi.getModel(componentName);
-                const transformedArgs = transformArgs(args, {
-                    contentType: component,
-                    usePagination: true
-                });
-                await strapi.contentAPI.validate.query(transformedArgs, component, {
-                    auth: ctx?.state?.auth
-                });
-                const sanitizedQuery = await strapi.contentAPI.sanitize.query(transformedArgs, component, {
-                    auth: ctx?.state?.auth
-                });
-                const dbQuery = strapi.get('query-params').transform(component.uid, sanitizedQuery);
-                return strapi.db?.query(contentTypeUID).load(parent, attributeName, dbQuery);
-            };
-        }
-    }));
-
-var dynamicZoneResolvers = (({ strapi })=>({
-        buildDynamicZoneResolver ({ contentTypeUID, attributeName }) {
-            return async (parent)=>{
-                return strapi.db?.query(contentTypeUID).load(parent, attributeName);
-            };
-        }
-    }));
-
-var paginationResolvers = (({ strapi })=>({
-        async resolvePagination (parent, _, ctx) {
-            const { args, resourceUID } = parent.info;
-            const { start, limit } = args;
-            const safeLimit = Math.max(limit, 1);
-            const contentType = strapi.getModel(resourceUID);
-            await strapi.contentAPI.validate.query(args, contentType, {
-                auth: ctx?.state?.auth
-            });
-            const sanitizedQuery = await strapi.contentAPI.sanitize.query(args, contentType, {
-                auth: ctx?.state?.auth
-            });
-            const total = await strapi.documents(resourceUID).count(sanitizedQuery);
-            const pageSize = limit === -1 ? total - start : safeLimit;
-            const pageCount = limit === -1 ? safeLimit : Math.ceil(total / safeLimit);
-            const page = limit === -1 ? safeLimit : Math.floor(start / safeLimit) + 1;
-            return {
-                total,
-                page,
-                pageSize,
-                pageCount
-            };
-        }
-    }));
-
-var resolvers = ((context)=>({
-        // Generics
-        ...associationResolvers(context),
-        // Builders
-        ...queriesResolvers(context),
-        ...componentResolvers(context),
-        ...dynamicZoneResolvers(context),
-        ...paginationResolvers(context)
-    }));
-
-const AND_FIELD_NAME = 'and';
-var andOperator = (()=>({
-        fieldName: AND_FIELD_NAME,
-        strapiOperator: '$and',
-        add (t, type) {
-            t.field(AND_FIELD_NAME, {
-                type: nexus.list(type)
-            });
-        }
-    }));
-
-const OR_FIELD_NAME = 'or';
-var orOperator = (()=>({
-        fieldName: OR_FIELD_NAME,
-        strapiOperator: '$or',
-        add (t, type) {
-            t.field(OR_FIELD_NAME, {
-                type: nexus.list(type)
-            });
-        }
-    }));
-
-const NOT_FIELD_NAME = 'not';
-var notOperator = (({ 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
-                });
-            }
-        }
-    }));
-
-const { ValidationError } = utils$2.errors;
-const EQ_FIELD_NAME = 'eq';
-var eqOperator = (({ 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
-            });
-        }
-    }));
-
-const EQI_FIELD_NAME = 'eqi';
-var eqiOperator = (()=>({
-        fieldName: EQI_FIELD_NAME,
-        strapiOperator: '$eqi',
-        add (t, type) {
-            t.field(EQI_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const NE_FIELD_NAME = 'ne';
-var neOperator = (()=>({
-        fieldName: NE_FIELD_NAME,
-        strapiOperator: '$ne',
-        add (t, type) {
-            t.field(NE_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const NEI_FIELD_NAME = 'nei';
-var neiOperator = (()=>({
-        fieldName: NEI_FIELD_NAME,
-        strapiOperator: '$nei',
-        add (t, type) {
-            t.field(NEI_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const STARTS_WITH_FIELD_NAME = 'startsWith';
-var startsWithOperator = (()=>({
-        fieldName: STARTS_WITH_FIELD_NAME,
-        strapiOperator: '$startsWith',
-        add (t, type) {
-            t.field(STARTS_WITH_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const ENDS_WITH_FIELD_NAME = 'endsWith';
-var endsWithOperator = (()=>({
-        fieldName: ENDS_WITH_FIELD_NAME,
-        strapiOperator: '$endsWith',
-        add (t, type) {
-            t.field(ENDS_WITH_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const CONTAINS_FIELD_NAME = 'contains';
-var containsOperator = (()=>({
-        fieldName: CONTAINS_FIELD_NAME,
-        strapiOperator: '$contains',
-        add (t, type) {
-            t.field(CONTAINS_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const NOT_CONTAINS_FIELD_NAME = 'notContains';
-var notContainsOperator = (()=>({
-        fieldName: NOT_CONTAINS_FIELD_NAME,
-        strapiOperator: '$notContains',
-        add (t, type) {
-            t.field(NOT_CONTAINS_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const CONTAINSI_FIELD_NAME = 'containsi';
-var containsiOperator = (()=>({
-        fieldName: CONTAINSI_FIELD_NAME,
-        strapiOperator: '$containsi',
-        add (t, type) {
-            t.field(CONTAINSI_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const NOT_CONTAINSI_FIELD_NAME = 'notContainsi';
-var notContainsiOperator = (()=>({
-        fieldName: NOT_CONTAINSI_FIELD_NAME,
-        strapiOperator: '$notContainsi',
-        add (t, type) {
-            t.field(NOT_CONTAINSI_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const GT_FIELD_NAME = 'gt';
-var gtOperator = (()=>({
-        fieldName: GT_FIELD_NAME,
-        strapiOperator: '$gt',
-        add (t, type) {
-            t.field(GT_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const GTE_FIELD_NAME = 'gte';
-var gteOperator = (()=>({
-        fieldName: GTE_FIELD_NAME,
-        strapiOperator: '$gte',
-        add (t, type) {
-            t.field(GTE_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const LT_FIELD_NAME = 'lt';
-var ltOperator = (()=>({
-        fieldName: LT_FIELD_NAME,
-        strapiOperator: '$lt',
-        add (t, type) {
-            t.field(LT_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const LTE_FIELD_NAME = 'lte';
-var lteOperator = (()=>({
-        fieldName: LTE_FIELD_NAME,
-        strapiOperator: '$lte',
-        add (t, type) {
-            t.field(LTE_FIELD_NAME, {
-                type
-            });
-        }
-    }));
-
-const NULL_FIELD_NAME = 'null';
-var nullOperator = (()=>({
-        fieldName: NULL_FIELD_NAME,
-        strapiOperator: '$null',
-        add (t) {
-            t.boolean(NULL_FIELD_NAME);
-        }
-    }));
-
-const NOT_NULL_FIELD_NAME = 'notNull';
-var notNullOperator = (()=>({
-        fieldName: NOT_NULL_FIELD_NAME,
-        strapiOperator: '$notNull',
-        add (t) {
-            t.boolean(NOT_NULL_FIELD_NAME);
-        }
-    }));
-
-const IN_FIELD_NAME = 'in';
-var inOperator = (()=>({
-        fieldName: IN_FIELD_NAME,
-        strapiOperator: '$in',
-        add (t, type) {
-            t.field(IN_FIELD_NAME, {
-                type: nexus.list(type)
-            });
-        }
-    }));
-
-const NOT_IN_FIELD_NAME = 'notIn';
-var notInOperator = (()=>({
-        fieldName: NOT_IN_FIELD_NAME,
-        strapiOperator: '$notIn',
-        add (t, type) {
-            t.field(NOT_IN_FIELD_NAME, {
-                type: nexus.list(type)
-            });
-        }
-    }));
-
-const BETWEEN_FIELD_NAME = 'between';
-var betweenOperator = (()=>({
-        fieldName: BETWEEN_FIELD_NAME,
-        strapiOperator: '$between',
-        add (t, type) {
-            t.field(BETWEEN_FIELD_NAME, {
-                type: nexus.list(type)
-            });
-        }
-    }));
-
-const operators = {
-    and: andOperator,
-    or: orOperator,
-    not: notOperator,
-    eq: eqOperator,
-    eqi: eqiOperator,
-    ne: neOperator,
-    nei: neiOperator,
-    startsWith: startsWithOperator,
-    endsWith: endsWithOperator,
-    contains: containsOperator,
-    notContains: notContainsOperator,
-    containsi: containsiOperator,
-    notContainsi: notContainsiOperator,
-    gt: gtOperator,
-    gte: gteOperator,
-    lt: ltOperator,
-    lte: lteOperator,
-    null: nullOperator,
-    notNull: notNullOperator,
-    in: inOperator,
-    notIn: notInOperator,
-    between: betweenOperator
-};
-// Instantiate every operator with the Strapi instance
-var operators$1 = (({ strapi })=>fp.mapValues((opCtor)=>opCtor({
-            strapi
-        }), operators));
-
-const { withDefaultPagination } = utils$2.pagination;
-var utils = (({ strapi })=>{
-    const { service: getService } = strapi.plugin('graphql');
-    return {
-        getContentTypeArgs (contentType, { multiple = true, isNested = false } = {}) {
-            const { naming } = getService('utils');
-            const { args } = getService('internals');
-            const { modelType } = contentType;
-            // Components
-            if (modelType === 'component') {
-                if (!multiple) return {};
-                return {
-                    filters: naming.getFiltersInputTypeName(contentType),
-                    pagination: args.PaginationArg,
-                    sort: args.SortArg
-                };
-            }
-            const { kind } = contentType;
-            // Collection Types
-            if (kind === 'collectionType') {
-                if (!multiple) {
-                    return {
-                        documentId: nexus.nonNull(nexus.idArg()),
-                        status: args.PublicationStatusArg
-                    };
-                }
-                const params = {
-                    filters: naming.getFiltersInputTypeName(contentType),
-                    pagination: args.PaginationArg,
-                    sort: args.SortArg
-                };
-                if (!isNested) {
-                    Object.assign(params, {
-                        status: args.PublicationStatusArg
-                    });
-                }
-                return params;
-            }
-            // Single Types
-            if (kind === 'singleType') {
-                const params = {};
-                if (!isNested) {
-                    Object.assign(params, {
-                        status: args.PublicationStatusArg
-                    });
-                }
-                return params;
-            }
-        },
-        /**
-     * Filter an object entries and keep only those whose value is a unique scalar attribute
-     */ getUniqueScalarAttributes (attributes) {
-            const { isStrapiScalar } = getService('utils').attributes;
-            const uniqueAttributes = fp.entries(attributes).filter(([, attribute])=>isStrapiScalar(attribute) && 'unique' in attribute && attribute.unique);
-            return Object.fromEntries(uniqueAttributes);
-        },
-        /**
-     * Map each value from an attribute to a FiltersInput type name
-     * @param {object} attributes - The attributes object to transform
-     * @return {Object<string, string>}
-     */ scalarAttributesToFiltersMap (attributes) {
-            return fp.mapValues((attribute)=>{
-                const { mappers, naming } = getService('utils');
-                const gqlScalar = mappers.strapiScalarToGraphQLScalar(attribute.type);
-                return naming.getScalarFilterInputTypeName(gqlScalar);
-            }, attributes);
-        },
-        /**
-     * Apply basic transform to GQL args
-     */ transformArgs (args, { contentType, usePagination = false }) {
-            const { mappers } = getService('utils');
-            const { config } = strapi.plugin('graphql');
-            const { pagination = {}, filters = {} } = args;
-            // Init
-            const newArgs = fp.omit([
-                'pagination',
-                'filters'
-            ], args);
-            // Pagination
-            if (usePagination) {
-                const defaultLimit = config('defaultLimit');
-                const maxLimit = config('maxLimit');
-                Object.assign(newArgs, withDefaultPagination(pagination, {
-                    maxLimit,
-                    defaults: {
-                        offset: {
-                            limit: defaultLimit
-                        },
-                        page: {
-                            pageSize: defaultLimit
-                        }
-                    }
-                }));
-            }
-            // Filters
-            if (args.filters) {
-                Object.assign(newArgs, {
-                    filters: mappers.graphQLFiltersToStrapiQuery(filters, contentType)
-                });
-            }
-            return newArgs;
-        }
-    };
-});
-
-const buildersFactories = [
-    enums,
-    dynamicZone,
-    entity,
-    typeBuilder,
-    response,
-    responseCollection,
-    relationResponseCollection,
-    queries,
-    mutations,
-    filters,
-    inputs,
-    genericMorph,
-    resolvers
-];
-var builders = (({ strapi })=>{
-    const buildersMap = new Map();
-    return {
-        /**
-     * Instantiate every builder with a strapi instance & a type registry
-     */ new (name, registry) {
-            const context = {
-                strapi,
-                registry
-            };
-            const builders = fp.pipe(// Create a new instance of every builders
-            fp.map((factory)=>factory(context)), // Merge every builder into the same object
-            fp.reduce(fp.merge, {})).call(null, buildersFactories);
-            buildersMap.set(name, builders);
-            return builders;
-        },
-        /**
-     * Delete a set of builders instances from
-     * the builders map for a given name
-     */ delete (name) {
-            buildersMap.delete(name);
-        },
-        /**
-     * Retrieve a set of builders instances from
-     * the builders map for a given name
-     */ get (name) {
-            return buildersMap.get(name);
-        },
-        filters: {
-            operators: operators$1({
-                strapi
-            })
-        },
-        utils: utils({
-            strapi
-        })
-    };
-});
-
-const getDefaultContentTypeConfig = ()=>({
-        enabled: true,
-        mutations: true,
-        queries: true,
-        disabledActions: [],
-        fields: new Map()
-    });
-const getDefaultFieldConfig = ()=>({
-        enabled: true,
-        input: true,
-        output: true,
-        filters: true
-    });
-const ALL_ACTIONS = '*';
-var createShadowCRUDManager = (()=>{
-    const configs = new Map();
-    return (uid)=>{
-        if (!configs.has(uid)) {
-            configs.set(uid, getDefaultContentTypeConfig());
-        }
-        return {
-            isEnabled () {
-                return configs.get(uid).enabled;
-            },
-            isDisabled () {
-                return !this.isEnabled();
-            },
-            areQueriesEnabled () {
-                return configs.get(uid).queries;
-            },
-            areQueriesDisabled () {
-                return !this.areQueriesEnabled();
-            },
-            areMutationsEnabled () {
-                return configs.get(uid).mutations;
-            },
-            areMutationsDisabled () {
-                return !this.areMutationsEnabled();
-            },
-            isActionEnabled (action) {
-                const matchingActions = [
-                    action,
-                    ALL_ACTIONS
-                ];
-                return configs.get(uid).disabledActions.every((action)=>!matchingActions.includes(action));
-            },
-            isActionDisabled (action) {
-                return !this.isActionEnabled(action);
-            },
-            disable () {
-                configs.get(uid).enabled = false;
-                return this;
-            },
-            disableQueries () {
-                configs.get(uid).queries = false;
-                return this;
-            },
-            disableMutations () {
-                configs.get(uid).mutations = false;
-                return this;
-            },
-            disableAction (action) {
-                const config = configs.get(uid);
-                if (!config.disabledActions.includes(action)) {
-                    config.disabledActions.push(action);
-                }
-                return this;
-            },
-            disableActions (actions = []) {
-                actions.forEach((action)=>this.disableAction(action));
-                return this;
-            },
-            field (fieldName) {
-                const { fields } = configs.get(uid);
-                if (!fields.has(fieldName)) {
-                    fields.set(fieldName, getDefaultFieldConfig());
-                }
-                return {
-                    isEnabled () {
-                        return fields.get(fieldName).enabled;
-                    },
-                    hasInputEnabled () {
-                        return fields.get(fieldName).input;
-                    },
-                    hasOutputEnabled () {
-                        return fields.get(fieldName).output;
-                    },
-                    hasFiltersEnabeld () {
-                        return fields.get(fieldName).filters;
-                    },
-                    disable () {
-                        fields.set(fieldName, {
-                            enabled: false,
-                            output: false,
-                            input: false,
-                            filters: false
-                        });
-                        return this;
-                    },
-                    disableOutput () {
-                        fields.get(fieldName).output = false;
-                        return this;
-                    },
-                    disableInput () {
-                        fields.get(fieldName).input = false;
-                        return this;
-                    },
-                    disableFilters () {
-                        fields.get(fieldName).filters = false;
-                        return this;
-                    }
-                };
-            }
-        };
-    };
-});
-
-const getDefaultState = ()=>({
-        types: [],
-        typeDefs: [],
-        resolvers: {},
-        resolversConfig: {},
-        plugins: []
-    });
-const createExtension = ({ strapi })=>{
-    const configs = [];
-    return {
-        shadowCRUD: createShadowCRUDManager(),
-        /**
-     * Register a new extension configuration
-     */ use (configuration) {
-            configs.push(configuration);
-            return this;
-        },
-        /**
-     * Convert the registered configuration into a single extension object & return it
-     */ generate ({ typeRegistry }) {
-            const resolveConfig = (config)=>{
-                return typeof config === 'function' ? config({
-                    strapi,
-                    nexus: nexus__namespace,
-                    typeRegistry
-                }) : config;
-            };
-            // Evaluate & merge every registered configuration object, then return the result
-            return configs.reduce((acc, configuration)=>{
-                const { types, typeDefs, resolvers, resolversConfig, plugins } = resolveConfig(configuration);
-                // Register type definitions
-                if (typeof typeDefs === 'string') {
-                    acc.typeDefs.push(typeDefs);
-                }
-                // Register nexus types
-                if (Array.isArray(types)) {
-                    acc.types.push(...types);
-                }
-                // Register nexus plugins
-                if (Array.isArray(plugins)) {
-                    acc.plugins.push(...plugins);
-                }
-                // Register resolvers
-                if (typeof resolvers === 'object') {
-                    acc.resolvers = fp.merge(acc.resolvers, resolvers);
-                }
-                // Register resolvers configuration
-                if (typeof resolversConfig === 'object') {
-                    // TODO: smarter merge for auth, middlewares & policies
-                    acc.resolversConfig = fp.merge(resolversConfig, acc.resolversConfig);
-                }
-                return acc;
-            }, getDefaultState());
-        }
-    };
-};
-
-var returnTypes = (()=>({
-        toEntityResponse (value, info = {}) {
-            const { args = {}, resourceUID } = info;
-            return {
-                value,
-                info: {
-                    args,
-                    resourceUID
-                }
-            };
-        },
-        toEntityResponseCollection (nodes, info = {}) {
-            const { args = {}, resourceUID } = info;
-            return {
-                nodes,
-                info: {
-                    args,
-                    resourceUID
-                }
-            };
-        }
-    }));
-
-var format = (()=>({
-        returnTypes: returnTypes()
-    }));
-
-const services = {
-    builders,
-    'content-api': contentAPI,
-    constants,
-    extension: createExtension,
-    format,
-    internals,
-    'type-registry': typeRegistry,
-    utils: utils$1
-};
+var index$1 = require('./config/index.js');
+var bootstrap = require('./bootstrap.js');
+var index$2 = require('./services/index.js');
 
 var index = {
-    config,
-    bootstrap,
-    services
+    config: index$1.config,
+    bootstrap: bootstrap.bootstrap,
+    services: index$2.services
 };
 
 module.exports = index;