@strapi/plugin-graphql 4.20.4 → 5.0.0-alpha.0

package/dist/server/index.js

@@ -1,10 +1,13 @@
 "use strict";
 const fp = require("lodash/fp");
-const apolloServerKoa = require("apollo-server-koa");
-const apolloServerCore = require("apollo-server-core");
+const server = require("@apollo/server");
+const _default = require("@apollo/server/plugin/landingPage/default");
+const koa = require("@as-integrations/koa");
 const depthLimit = require("graphql-depth-limit");
-const graphqlUpload = require("graphql-upload");
+const bodyParser = require("koa-bodyparser");
+const cors = require("@koa/cors");
 const utils$2 = require("@strapi/utils");
+const errors = require("@apollo/server/errors");
 const graphql = require("graphql");
 const utils$3 = require("@graphql-tools/utils");
 const nexus = require("nexus");
@@ -30,13 +33,16 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 const depthLimit__default = /* @__PURE__ */ _interopDefault(depthLimit);
+const bodyParser__default = /* @__PURE__ */ _interopDefault(bodyParser);
+const cors__default = /* @__PURE__ */ _interopDefault(cors);
 const nexus__namespace = /* @__PURE__ */ _interopNamespace(nexus);
 const defaultConfig = {
   shadowCRUD: true,
   endpoint: "/graphql",
   subscriptions: false,
   maxLimit: -1,
-  apolloServer: {}
+  apolloServer: {},
+  v4CompatibilityMode: process.env.STRAPI_GRAPHQL_V4_COMPATIBILITY_MODE ?? false
 };
 const config = {
   default: defaultConfig
@@ -46,41 +52,49 @@ const formatToCode = (name) => `STRAPI_${fp.toUpper(fp.snakeCase(name))}`;
 const formatErrorToExtension = (error2) => ({
   error: fp.pick(["name", "message", "details"])(error2)
 });
-function formatGraphqlError(error2) {
-  const { originalError } = error2;
+function createFormattedError(formattedError, message, code, originalError) {
+  const options = {
+    ...formattedError,
+    extensions: {
+      ...formattedError.extensions,
+      ...formatErrorToExtension(originalError),
+      code
+    }
+  };
+  return new graphql.GraphQLError(message, options);
+}
+function formatGraphqlError(formattedError, error2) {
+  const originalError = errors.unwrapResolverError(error2);
   if (fp.isEmpty(originalError)) {
-    return error2;
+    return formattedError;
   }
+  const { message = "", name = "UNKNOWN" } = originalError;
   if (originalError instanceof ForbiddenError$1 || originalError instanceof UnauthorizedError) {
-    return new apolloServerKoa.ForbiddenError(originalError.message, formatErrorToExtension(originalError));
+    return createFormattedError(formattedError, message, "FORBIDDEN", originalError);
   }
   if (originalError instanceof ValidationError$3) {
-    return new apolloServerKoa.UserInputError(originalError.message, formatErrorToExtension(originalError));
+    return createFormattedError(formattedError, message, "BAD_USER_INPUT", originalError);
   }
   if (originalError instanceof ApplicationError$5 || originalError instanceof HttpError) {
-    const name = formatToCode(originalError.name);
-    return new apolloServerKoa.ApolloError(originalError.message, name, formatErrorToExtension(originalError));
+    const errorName = formatToCode(name);
+    return createFormattedError(formattedError, message, errorName, originalError);
   }
-  if (originalError instanceof apolloServerKoa.ApolloError || originalError instanceof graphql.GraphQLError) {
-    return error2;
+  if (originalError instanceof graphql.GraphQLError) {
+    return formattedError;
   }
   strapi.log.error(originalError);
-  return new apolloServerKoa.ApolloError("Internal Server Error", "INTERNAL_SERVER_ERROR");
+  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 useUploadMiddleware = (strapi2, path) => {
-  const uploadMiddleware = graphqlUpload.graphqlUploadKoa();
-  strapi2.server.app.use((ctx, next) => {
-    if (ctx.path === path) {
-      return uploadMiddleware(ctx, next);
-    }
-    return next();
-  });
-};
 async function bootstrap({ strapi: strapi2 }) {
   const schema = strapi2.plugin("graphql").service("content-api").buildSchema();
   if (fp.isEmpty(schema)) {
@@ -89,14 +103,18 @@ async function bootstrap({ strapi: strapi2 }) {
   }
   const { config: config2 } = strapi2.plugin("graphql");
   const path = config2("endpoint");
+  const playgroundEnabled = !(process.env.NODE_ENV === "production" && !config2("playgroundAlways"));
+  let landingPage;
+  if (playgroundEnabled) {
+    landingPage = _default.ApolloServerPluginLandingPageLocalDefault();
+    strapi2.log.debug("Using Apollo sandbox landing page");
+  } else {
+    landingPage = _default.ApolloServerPluginLandingPageProductionDefault();
+    strapi2.log.debug("Using Apollo production landing page");
+  }
   const defaultServerConfig = {
     // Schema
     schema,
-    // Initialize loaders for this request.
-    context: ({ ctx }) => ({
-      state: ctx.state,
-      koaContext: ctx
-    }),
     // Validation
     validationRules: [depthLimit__default.default(config2("depthLimit"))],
     // Errors
@@ -105,52 +123,68 @@ async function bootstrap({ strapi: strapi2 }) {
     cors: false,
     uploads: false,
     bodyParserConfig: true,
-    plugins: [
-      process.env.NODE_ENV === "production" && !config2("playgroundAlways") ? apolloServerCore.ApolloServerPluginLandingPageDisabled() : apolloServerCore.ApolloServerPluginLandingPageGraphQLPlayground()
-    ],
+    // send 400 http status instead of 200 for input validation errors
+    status400ForVariableCoercionErrors: true,
+    plugins: [landingPage],
     cache: "bounded"
   };
-  const serverConfig = merge(defaultServerConfig, config2("apolloServer"));
-  const server = new apolloServerKoa.ApolloServer(serverConfig);
-  useUploadMiddleware(strapi2, path);
+  const serverConfig = merge(
+    defaultServerConfig,
+    config2("apolloServer")
+  );
+  const server$1 = new server.ApolloServer(serverConfig);
   try {
-    await server.start();
+    await server$1.start();
   } catch (error2) {
     if (error2 instanceof Error) {
       strapi2.log.error("Failed to start the Apollo server", error2.message);
     }
     throw error2;
   }
+  const handler = [];
+  if (cors__default.default) {
+    handler.push(cors__default.default());
+  }
+  if (fp.isObject(serverConfig.bodyParserConfig)) {
+    handler.push(bodyParser__default.default(serverConfig.bodyParserConfig));
+  } else if (serverConfig.bodyParserConfig) {
+    handler.push(bodyParser__default.default());
+  } else {
+    strapi2.log.debug("Body parser has been disabled for Apollo server");
+  }
+  handler.push((ctx, next) => {
+    ctx.state.route = {
+      info: {
+        // Indicate it's a content API route
+        type: "content-api"
+      }
+    };
+    if (ctx.request.method === "GET") {
+      return next();
+    }
+    return strapi2.auth.authenticate(ctx, next);
+  });
+  handler.push(
+    koa.koaMiddleware(server$1, {
+      // Initialize loaders for this request.
+      context: async ({ ctx }) => ({
+        state: ctx.state,
+        koaContext: ctx
+      })
+    })
+  );
   strapi2.server.routes([
     {
       method: "ALL",
       path,
-      handler: [
-        (ctx, next) => {
-          ctx.state.route = {
-            info: {
-              // Indicate it's a content API route
-              type: "content-api"
-            }
-          };
-          if (ctx.request.method === "GET")
-            return next();
-          return strapi2.auth.authenticate(ctx, next);
-        },
-        // Apollo Server
-        server.getMiddleware({
-          path,
-          cors: serverConfig.cors,
-          bodyParserConfig: serverConfig.bodyParserConfig
-        })
-      ],
+      handler,
       config: {
         auth: false
       }
     }
   ]);
   strapi2.plugin("graphql").destroy = async () => {
-    await server.stop();
+    await server$1.stop();
   };
 }
 const { PolicyError } = utils$2.errors;
@@ -454,7 +488,7 @@ const registerInternals = ({ registry, strapi: strapi2 }) => {
     registry.registerMany(Object.entries(definitions), { kind });
   }
 };
-const registerDynamicZonesDefinition$1 = (contentType2, {
+const registerDynamicZonesDefinition = (contentType2, {
   registry,
   strapi: strapi2,
   builders: builders2
@@ -483,7 +517,7 @@ const registerDynamicZonesDefinition$1 = (contentType2, {
     registry.register(dzInputName, input, { kind: KINDS2.input, ...baseConfig });
   }
 };
-const registerEnumsDefinition$1 = (contentType2, {
+const registerEnumsDefinition = (contentType2, {
   registry,
   strapi: strapi2,
   builders: builders2
@@ -510,7 +544,7 @@ const registerEnumsDefinition$1 = (contentType2, {
     });
   }
 };
-const registerInputsDefinition$1 = (contentType2, {
+const registerInputsDefinition = (contentType2, {
   registry,
   strapi: strapi2,
   builders: builders2
@@ -526,7 +560,7 @@ const registerInputsDefinition$1 = (contentType2, {
   const definition = builders2.buildInputType(contentType2);
   registry.register(type, definition, { kind: KINDS2.input, contentType: contentType2 });
 };
-const registerFiltersDefinition$1 = (contentType2, {
+const registerFiltersDefinition = (contentType2, {
   registry,
   strapi: strapi2,
   builders: builders2
@@ -538,18 +572,6 @@ const registerFiltersDefinition$1 = (contentType2, {
   const definition = builders2.buildContentTypeFilters(contentType2);
   registry.register(type, definition, { kind: KINDS2.filtersInput, contentType: contentType2 });
 };
-const contentType$1 = {
-  registerDynamicZonesDefinition: registerDynamicZonesDefinition$1,
-  registerFiltersDefinition: registerFiltersDefinition$1,
-  registerInputsDefinition: registerInputsDefinition$1,
-  registerEnumsDefinition: registerEnumsDefinition$1
-};
-const {
-  registerEnumsDefinition,
-  registerInputsDefinition,
-  registerFiltersDefinition,
-  registerDynamicZonesDefinition
-} = contentType$1;
 const contentAPI = ({ strapi: strapi2 }) => {
   const { mergeSchemas, addResolversToSchema } = require("@graphql-tools/schema");
   const { service: getGraphQLService } = strapi2.plugin("graphql");
@@ -736,7 +758,7 @@ const strapiScalarToGraphQLScalar = ({ strapi: strapi2 }) => {
     }
   };
 };
-const virtualScalarAttributes = ["id"];
+const virtualScalarAttributes = ["id", "documentId"];
 const graphQLFiltersToStrapiQuery = ({ strapi: strapi2 }) => {
   const { service: getService } = strapi2.plugin("graphql");
   const recursivelyReplaceScalarOperators = (data) => {
@@ -950,6 +972,9 @@ const naming = ({ strapi: strapi2 }) => {
     plurality: "plural",
     firstLetterCase: "lower"
   });
+  const getFindConnectionQueryName = (contentType2) => {
+    return `${getFindQueryName(contentType2)}_connection`;
+  };
   const getFindOneQueryName = buildCustomTypeNameGenerator({ firstLetterCase: "lower" });
   const getCreateMutationTypeName = buildCustomTypeNameGenerator({
     prefix: "create",
@@ -987,16 +1012,26 @@ const naming = ({ strapi: strapi2 }) => {
     getFindOneQueryName,
     getCreateMutationTypeName,
     getUpdateMutationTypeName,
-    getDeleteMutationTypeName
+    getDeleteMutationTypeName,
+    getFindConnectionQueryName
+  };
+};
+const playground = (ctx) => {
+  return {
+    isEnabled() {
+      return !(process.env.NODE_ENV === "production" && !ctx.strapi.plugin("graphql").config("playgroundAlways"));
+    }
   };
 };
 const utils$1 = (context) => ({
+  playground: playground(context),
   naming: naming(context),
   attributes: attributes(context),
   mappers: mappers(context)
 });
 const PAGINATION_TYPE_NAME = "Pagination";
-const PUBLICATION_STATE_TYPE_NAME = "PublicationState";
+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 = [
@@ -1117,7 +1152,8 @@ const ERROR_CODES = {
 const constants = () => ({
   PAGINATION_TYPE_NAME,
   RESPONSE_COLLECTION_META_TYPE_NAME,
-  PUBLICATION_STATE_TYPE_NAME,
+  DELETE_MUTATION_RESPONSE_TYPE_NAME,
+  PUBLICATION_STATUS_TYPE_NAME,
   GRAPHQL_SCALARS,
   STRAPI_SCALARS,
   GENERIC_MORPH_TYPENAME,
@@ -1131,11 +1167,11 @@ const SortArg = nexus.arg({
   type: nexus.list("String"),
   default: []
 });
-const publicationState$1 = ({ strapi: strapi2 }) => {
-  const { PUBLICATION_STATE_TYPE_NAME: PUBLICATION_STATE_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
+const publicationStatus$1 = ({ strapi: strapi2 }) => {
+  const { PUBLICATION_STATUS_TYPE_NAME: PUBLICATION_STATUS_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
   return nexus.arg({
-    type: PUBLICATION_STATE_TYPE_NAME2,
-    default: "live"
+    type: PUBLICATION_STATUS_TYPE_NAME2,
+    default: "published"
   });
 };
 const PaginationInputType = nexus.inputObjectType({
@@ -1154,7 +1190,7 @@ const PaginationArg = nexus.arg({
 const args = (context) => ({
   SortArg,
   PaginationArg,
-  PublicationStateArg: publicationState$1(context)
+  PublicationStatusArg: publicationStatus$1(context)
 });
 const { ValidationError: ValidationError$2 } = utils$2.errors;
 const TimeScalar = new graphql.GraphQLScalarType({
@@ -1188,8 +1224,7 @@ const scalars = () => ({
   DateTime: nexus.asNexusMethod(graphqlScalars.GraphQLDateTime, "dateTime"),
   Time: nexus.asNexusMethod(TimeScalar, "time"),
   Date: nexus.asNexusMethod(graphqlScalars.GraphQLDate, "date"),
-  Long: nexus.asNexusMethod(graphqlScalars.GraphQLLong, "long"),
-  Upload: nexus.asNexusMethod(graphqlUpload.GraphQLUpload, "upload")
+  Long: nexus.asNexusMethod(graphqlScalars.GraphQLLong, "long")
 });
 const pagination = ({ strapi: strapi2 }) => {
   const { PAGINATION_TYPE_NAME: PAGINATION_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
@@ -1210,7 +1245,8 @@ const pagination = ({ strapi: strapi2 }) => {
   };
 };
 const buildResponseCollectionMeta = ({ strapi: strapi2 }) => {
-  const { RESPONSE_COLLECTION_META_TYPE_NAME: RESPONSE_COLLECTION_META_TYPE_NAME2, PAGINATION_TYPE_NAME: PAGINATION_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
+  const { service: getService } = strapi2.plugin("graphql");
+  const { RESPONSE_COLLECTION_META_TYPE_NAME: RESPONSE_COLLECTION_META_TYPE_NAME2, PAGINATION_TYPE_NAME: PAGINATION_TYPE_NAME2 } = getService("constants");
   return {
     /**
      * A shared type definition used in EntitiesResponseCollection
@@ -1220,44 +1256,38 @@ const buildResponseCollectionMeta = ({ strapi: strapi2 }) => {
     ResponseCollectionMeta: nexus.objectType({
       name: RESPONSE_COLLECTION_META_TYPE_NAME2,
       definition(t) {
+        const { resolvePagination } = getService("builders").get("content-api");
         t.nonNull.field("pagination", {
           type: PAGINATION_TYPE_NAME2,
-          async resolve(parent, _childArgs, ctx) {
-            const { args: args2, resourceUID } = parent;
-            const { start, limit } = args2;
-            const safeLimit = Math.max(limit, 1);
-            const contentType2 = strapi2.getModel(resourceUID);
-            await utils$2.validate.contentAPI.query(args2, contentType2, {
-              auth: ctx?.state?.auth
-            });
-            const sanitizedQuery = await utils$2.sanitize.contentAPI.query(args2, contentType2, {
-              auth: ctx?.state?.auth
-            });
-            const total = await strapi2.entityService.count(resourceUID, 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 };
-          }
+          resolve: resolvePagination
         });
       }
     })
   };
 };
-const publicationState = ({ strapi: strapi2 }) => {
-  const { PUBLICATION_STATE_TYPE_NAME: PUBLICATION_STATE_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
+const buildDeleteMutationResponse = ({ strapi: strapi2 }) => {
+  const { DELETE_MUTATION_RESPONSE_TYPE_NAME: DELETE_MUTATION_RESPONSE_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
+  return {
+    DeleteMutationResponse: nexus.objectType({
+      name: DELETE_MUTATION_RESPONSE_TYPE_NAME2,
+      definition(t) {
+        t.nonNull.id("documentId");
+      }
+    })
+  };
+};
+const publicationStatus = ({ strapi: strapi2 }) => {
+  const { PUBLICATION_STATUS_TYPE_NAME: PUBLICATION_STATUS_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
   return {
     /**
-     * An enum type definition representing a publication state
+     * An enum type definition representing a publication status
      * @type {NexusEnumTypeDef}
      */
-    PublicationState: nexus.enumType({
-      name: PUBLICATION_STATE_TYPE_NAME2,
+    PublicationStatus: nexus.enumType({
+      name: PUBLICATION_STATUS_TYPE_NAME2,
       members: {
-        // Published only
-        LIVE: "live",
-        // Published & draft
-        PREVIEW: "preview"
+        DRAFT: "draft",
+        PUBLISHED: "published"
       }
     })
   };
@@ -1314,10 +1344,11 @@ const types = (context) => () => {
     [KINDS2.internal]: {
       error: error(context),
       pagination: pagination(context),
-      responseCollectionMeta: buildResponseCollectionMeta(context)
+      responseCollectionMeta: buildResponseCollectionMeta(context),
+      deleteDocumentResponse: buildDeleteMutationResponse(context)
     },
     [KINDS2.enum]: {
-      publicationState: publicationState(context)
+      publicationStatus: publicationStatus(context)
     },
     [KINDS2.filtersInput]: {
       ...filters$1(context)
@@ -1341,7 +1372,7 @@ const buildEnumTypeDefinition = (definition, name) => {
   return nexus.enumType({
     name,
     members: definition.enum.reduce(
-      (acc, value) => fp.set(utils$2.toRegressedEnumValue(value), value, acc),
+      (acc, value) => fp.set(utils$2.strings.toRegressedEnumValue(value), value, acc),
       {}
     )
   });
@@ -1447,11 +1478,6 @@ const entity = ({ strapi: strapi2 }) => {
     }
   };
 };
-function buildEntityMetaDefinition() {
-}
-const entityMeta = () => ({
-  buildEntityMetaDefinition
-});
 const typeBuilder = (context) => {
   const { strapi: strapi2 } = context;
   const getGraphQLService = strapi2.plugin("graphql").service;
@@ -1478,7 +1504,10 @@ const typeBuilder = (context) => {
       attributeName,
       strapi: strapi2
     });
-    const args2 = getContentTypeArgs(targetComponent, { multiple: !!attribute.repeatable });
+    const args2 = getContentTypeArgs(targetComponent, {
+      multiple: !!attribute.repeatable,
+      isNested: true
+    });
     localBuilder.field(attributeName, { type, resolve, args: args2 });
   };
   const addDynamicZoneAttribute = (options) => {
@@ -1527,9 +1556,32 @@ const typeBuilder = (context) => {
       attributeName,
       strapi: strapi2
     });
-    const args2 = attribute.multiple ? getContentTypeArgs(fileContentType) : void 0;
-    const type = attribute.multiple ? naming2.getRelationResponseCollectionName(fileContentType) : naming2.getEntityResponseName(fileContentType);
-    builder.field(attributeName, { type, resolve, args: args2 });
+    const args2 = attribute.multiple ? getContentTypeArgs(fileContentType, { isNested: true }) : void 0;
+    const typeName = naming2.getTypeName(fileContentType);
+    if (attribute.multiple) {
+      builder.field(`${attributeName}_connection`, {
+        type: naming2.getRelationResponseCollectionName(fileContentType),
+        resolve,
+        args: args2
+      });
+      builder.field(attributeName, {
+        type: nexus.nonNull(nexus.list(typeName)),
+        async resolve(...args22) {
+          const res = await resolve(...args22);
+          return res.nodes ?? [];
+        },
+        args: args2
+      });
+    } else {
+      builder.field(attributeName, {
+        type: typeName,
+        async resolve(...args22) {
+          const res = await resolve(...args22);
+          return res.value;
+        },
+        args: args2
+      });
+    }
   };
   const addPolymorphicRelationalAttribute = (options) => {
     const { GENERIC_MORPH_TYPENAME: GENERIC_MORPH_TYPENAME2 } = getGraphQLService("constants");
@@ -1574,12 +1626,38 @@ const typeBuilder = (context) => {
       strapi: strapi2
     });
     const targetContentType = strapi2.getModel(attribute.target);
-    const type = isToManyRelation ? naming2.getRelationResponseCollectionName(targetContentType) : naming2.getEntityResponseName(targetContentType);
-    const args2 = isToManyRelation ? getContentTypeArgs(targetContentType) : void 0;
-    const resolverPath = `${naming2.getTypeName(contentType2)}.${attributeName}`;
+    const typeName = naming2.getTypeName(targetContentType);
+    const args2 = isToManyRelation ? getContentTypeArgs(targetContentType, { isNested: true }) : void 0;
     const resolverScope = `${targetContentType.uid}.find`;
+    const resolverPath = `${naming2.getTypeName(contentType2)}.${attributeName}`;
     extension2.use({ resolversConfig: { [resolverPath]: { auth: { scope: [resolverScope] } } } });
-    builder.field(attributeName, { type, resolve, args: args2 });
+    if (isToManyRelation) {
+      builder.field(`${attributeName}_connection`, {
+        type: naming2.getRelationResponseCollectionName(targetContentType),
+        resolve,
+        args: args2
+      });
+      extension2.use({
+        resolversConfig: { [`${resolverPath}_connection`]: { auth: { scope: [resolverScope] } } }
+      });
+      builder.field(attributeName, {
+        type: nexus.nonNull(nexus.list(typeName)),
+        async resolve(...args22) {
+          const res = await resolve(...args22);
+          return res.nodes ?? [];
+        },
+        args: args2
+      });
+    } else {
+      builder.field(attributeName, {
+        type: typeName,
+        async resolve(...args22) {
+          const res = await resolve(...args22);
+          return res.value;
+        },
+        args: args2
+      });
+    }
   };
   const isNotPrivate = (contentType2) => (attributeName) => {
     return !utils$2.contentTypes.isPrivateAttribute(contentType2, attributeName);
@@ -1614,9 +1692,29 @@ const typeBuilder = (context) => {
       return nexus.objectType({
         name,
         definition(t) {
+          if (modelType !== "component" && isNotDisabled(contentType2)("id") && strapi2.plugin("graphql").config("v4CompatibilityMode", false)) {
+            t.nonNull.id("id", {
+              deprecation: "Use `documentId` instead"
+            });
+          }
           if (modelType === "component" && isNotDisabled(contentType2)("id")) {
             t.nonNull.id("id");
           }
+          if (modelType !== "component" && isNotDisabled(contentType2)("documentId")) {
+            t.nonNull.id("documentId");
+          }
+          if (strapi2.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
+            });
+          }
           attributesKey.filter(isNotPrivate(contentType2)).filter(isNotDisabled(contentType2)).forEach((attributeName) => {
             const attribute = attributes2[attributeName];
             let builder = t;
@@ -1659,12 +1757,12 @@ const response = ({ strapi: strapi2 }) => {
      */
     buildResponseDefinition(contentType2) {
       const name = naming2.getEntityResponseName(contentType2);
-      const entityName = naming2.getEntityName(contentType2);
+      const typeName = naming2.getTypeName(contentType2);
       return nexus.objectType({
         name,
         definition(t) {
           t.field("data", {
-            type: entityName,
+            type: typeName,
             resolve: fp.prop("value")
           });
         }
@@ -1673,8 +1771,9 @@ const response = ({ strapi: strapi2 }) => {
   };
 };
 const responseCollection = ({ strapi: strapi2 }) => {
-  const { naming: naming2 } = strapi2.plugin("graphql").service("utils");
-  const { RESPONSE_COLLECTION_META_TYPE_NAME: RESPONSE_COLLECTION_META_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
+  const { service: getService } = strapi2.plugin("graphql");
+  const { naming: naming2 } = getService("utils");
+  const { RESPONSE_COLLECTION_META_TYPE_NAME: RESPONSE_COLLECTION_META_TYPE_NAME2, PAGINATION_TYPE_NAME: PAGINATION_TYPE_NAME2 } = getService("constants");
   return {
     /**
      * Build a type definition for a content API collection response for a given content type
@@ -1683,19 +1782,31 @@ const responseCollection = ({ strapi: strapi2 }) => {
      */
     buildResponseCollectionDefinition(contentType2) {
       const name = naming2.getEntityResponseCollectionName(contentType2);
-      const entityName = naming2.getEntityName(contentType2);
+      const typeName = naming2.getTypeName(contentType2);
+      const { resolvePagination } = getService("builders").get("content-api");
       return nexus.objectType({
         name,
         definition(t) {
-          t.nonNull.list.field("data", {
-            type: nexus.nonNull(entityName),
+          t.nonNull.list.field("nodes", {
+            type: nexus.nonNull(typeName),
             resolve: fp.pipe(fp.prop("nodes"), fp.defaultTo([]))
           });
-          t.nonNull.field("meta", {
-            type: RESPONSE_COLLECTION_META_TYPE_NAME2,
-            // Pass down the args stored in the source object
-            resolve: fp.prop("info")
+          t.nonNull.field("pageInfo", {
+            type: PAGINATION_TYPE_NAME2,
+            resolve: resolvePagination
           });
+          if (strapi2.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_NAME2,
+              resolve: fp.identity
+            });
+          }
         }
       });
     }
@@ -1709,14 +1820,21 @@ const relationResponseCollection = ({ strapi: strapi2 }) => {
      */
     buildRelationResponseCollectionDefinition(contentType2) {
       const name = naming2.getRelationResponseCollectionName(contentType2);
-      const entityName = naming2.getEntityName(contentType2);
+      const typeName = naming2.getTypeName(contentType2);
       return nexus.objectType({
         name,
         definition(t) {
-          t.nonNull.list.field("data", {
-            type: nexus.nonNull(entityName),
+          t.nonNull.list.field("nodes", {
+            type: nexus.nonNull(typeName),
             resolve: fp.pipe(fp.prop("nodes"), fp.defaultTo([]))
           });
+          if (strapi2.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([]))
+            });
+          }
         }
       });
     }
@@ -1726,16 +1844,18 @@ const createCollectionTypeQueriesBuilder = ({ strapi: strapi2 }) => {
   const { service: getService } = strapi2.plugin("graphql");
   const { naming: naming2 } = getService("utils");
   const { transformArgs, getContentTypeArgs } = getService("builders").utils;
-  const { toEntityResponse, toEntityResponseCollection } = getService("format").returnTypes;
+  const { toEntityResponseCollection } = getService("format").returnTypes;
   const {
     getFindOneQueryName,
-    getEntityResponseName,
+    getTypeName,
     getFindQueryName,
+    getFindConnectionQueryName,
     getEntityResponseCollectionName
   } = naming2;
   const buildCollectionTypeQueries = (contentType2) => {
     const findOneQueryName = `Query.${getFindOneQueryName(contentType2)}`;
     const findQueryName = `Query.${getFindQueryName(contentType2)}`;
+    const findConnectionQueryName = `Query.${getFindConnectionQueryName(contentType2)}`;
     const extension = getService("extension");
     const registerAuthConfig = (action, auth) => {
       return extension.use({ resolversConfig: { [action]: { auth } } });
@@ -1750,6 +1870,7 @@ const createCollectionTypeQueriesBuilder = ({ strapi: strapi2 }) => {
     }
     if (isFindEnabled) {
       registerAuthConfig(findQueryName, { scope: [`${contentType2.uid}.find`] });
+      registerAuthConfig(findConnectionQueryName, { scope: [`${contentType2.uid}.find`] });
     }
     return nexus.extendType({
       type: "Query",
@@ -1758,37 +1879,64 @@ const createCollectionTypeQueriesBuilder = ({ strapi: strapi2 }) => {
           addFindOneQuery(t, contentType2);
         }
         if (isFindEnabled) {
+          addFindConnectionQuery(t, contentType2);
           addFindQuery(t, contentType2);
         }
       }
     });
   };
   const addFindOneQuery = (t, contentType2) => {
-    const { uid } = contentType2;
     const findOneQueryName = getFindOneQueryName(contentType2);
-    const responseTypeName = getEntityResponseName(contentType2);
+    const typeName = getTypeName(contentType2);
     t.field(findOneQueryName, {
-      type: responseTypeName,
+      type: typeName,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: getContentTypeArgs(contentType2, { multiple: false }),
       async resolve(parent, args2, ctx) {
         const transformedArgs = transformArgs(args2, { contentType: contentType2 });
         const { findOne } = getService("builders").get("content-api").buildQueriesResolvers({ contentType: contentType2 });
-        const value = findOne(parent, transformedArgs, ctx);
-        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+        return findOne(parent, transformedArgs, ctx);
       }
     });
   };
   const addFindQuery = (t, contentType2) => {
-    const { uid } = contentType2;
     const findQueryName = getFindQueryName(contentType2);
-    const responseCollectionTypeName = getEntityResponseCollectionName(contentType2);
+    const typeName = getTypeName(contentType2);
     t.field(findQueryName, {
+      type: nexus.nonNull(nexus.list(typeName)),
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
+      args: getContentTypeArgs(contentType2),
+      async resolve(parent, args2, ctx) {
+        const transformedArgs = transformArgs(args2, { contentType: contentType2, usePagination: true });
+        const { findMany } = getService("builders").get("content-api").buildQueriesResolvers({ contentType: contentType2 });
+        return findMany(parent, transformedArgs, ctx);
+      }
+    });
+  };
+  const addFindConnectionQuery = (t, contentType2) => {
+    const { uid } = contentType2;
+    const queryName = getFindConnectionQueryName(contentType2);
+    const responseCollectionTypeName = getEntityResponseCollectionName(contentType2);
+    t.field(queryName, {
       type: responseCollectionTypeName,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: getContentTypeArgs(contentType2),
       async resolve(parent, args2, ctx) {
         const transformedArgs = transformArgs(args2, { contentType: contentType2, usePagination: true });
-        const { find } = getService("builders").get("content-api").buildQueriesResolvers({ contentType: contentType2 });
-        const nodes = await find(parent, transformedArgs, ctx);
+        const { findMany } = getService("builders").get("content-api").buildQueriesResolvers({ contentType: contentType2 });
+        const nodes = await findMany(parent, transformedArgs, ctx);
         return toEntityResponseCollection(nodes, { args: transformedArgs, resourceUID: uid });
       }
     });
@@ -1799,8 +1947,7 @@ const createSingleTypeQueriesBuilder = ({ strapi: strapi2 }) => {
   const { service: getService } = strapi2.plugin("graphql");
   const { naming: naming2 } = getService("utils");
   const { transformArgs, getContentTypeArgs } = getService("builders").utils;
-  const { toEntityResponse } = getService("format").returnTypes;
-  const { getFindOneQueryName, getEntityResponseName } = naming2;
+  const { getFindOneQueryName, getTypeName } = naming2;
   const buildSingleTypeQueries = (contentType2) => {
     const findQueryName = `Query.${getFindOneQueryName(contentType2)}`;
     const extension = getService("extension");
@@ -1824,17 +1971,20 @@ const createSingleTypeQueriesBuilder = ({ strapi: strapi2 }) => {
     });
   };
   const addFindQuery = (t, contentType2) => {
-    const { uid } = contentType2;
     const findQueryName = getFindOneQueryName(contentType2);
-    const responseTypeName = getEntityResponseName(contentType2);
+    const typeName = getTypeName(contentType2);
     t.field(findQueryName, {
-      type: responseTypeName,
+      type: typeName,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: getContentTypeArgs(contentType2),
       async resolve(parent, args2, ctx) {
         const transformedArgs = transformArgs(args2, { contentType: contentType2 });
-        const queriesResolvers2 = getService("builders").get("content-api").buildQueriesResolvers({ contentType: contentType2 });
-        const value = queriesResolvers2.find(parent, transformedArgs, ctx);
-        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+        const { findFirst } = getService("builders").get("content-api").buildQueriesResolvers({ contentType: contentType2 });
+        return findFirst(parent, transformedArgs, ctx);
       }
     });
   };
@@ -1847,86 +1997,89 @@ const queries = (context) => ({
 const createCollectionTypeMutationsBuilder = ({ strapi: strapi2 }) => {
   const { service: getService } = strapi2.plugin("graphql");
   const { naming: naming2 } = getService("utils");
-  const { transformArgs } = getService("builders").utils;
-  const { toEntityResponse } = getService("format").returnTypes;
+  const { args: args2 } = getService("internals");
   const {
     getCreateMutationTypeName,
     getUpdateMutationTypeName,
     getDeleteMutationTypeName,
-    getEntityResponseName,
-    getContentTypeInputName
+    getContentTypeInputName,
+    getTypeName
   } = naming2;
   const addCreateMutation = (t, contentType2) => {
     const { uid } = contentType2;
     const createMutationName = getCreateMutationTypeName(contentType2);
-    const responseTypeName = getEntityResponseName(contentType2);
+    const typeName = getTypeName(contentType2);
     t.field(createMutationName, {
-      type: responseTypeName,
+      type: typeName,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: {
         // Create payload
+        status: args2.PublicationStatusArg,
         data: nexus.nonNull(getContentTypeInputName(contentType2))
       },
-      async resolve(parent, args2, context) {
+      async resolve(parent, args22, context) {
         const { auth } = context.state;
-        const transformedArgs = transformArgs(args2, { contentType: contentType2 });
-        const sanitizedInputData = await utils$2.sanitize.contentAPI.input(
-          transformedArgs.data,
-          contentType2,
-          { auth }
-        );
-        Object.assign(transformedArgs, { data: sanitizedInputData });
-        const { create } = getService("builders").get("content-api").buildMutationsResolvers({ contentType: contentType2 });
-        const value = await create(parent, transformedArgs);
-        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+        const sanitizedInputData = await utils$2.sanitize.contentAPI.input(args22.data, contentType2, {
+          auth
+        });
+        return strapi2.documents(uid).create({
+          ...args22,
+          data: sanitizedInputData
+        });
       }
     });
   };
   const addUpdateMutation = (t, contentType2) => {
     const { uid } = contentType2;
     const updateMutationName = getUpdateMutationTypeName(contentType2);
-    const responseTypeName = getEntityResponseName(contentType2);
+    const typeName = getTypeName(contentType2);
     t.field(updateMutationName, {
-      type: responseTypeName,
+      type: typeName,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: {
-        // Query args
-        id: nexus.nonNull("ID"),
-        // todo[v4]: Don't allow to filter using every unique attributes for now
-        // ...uniqueAttributes,
-        // Update payload
+        documentId: nexus.nonNull(nexus.idArg()),
+        status: args2.PublicationStatusArg,
         data: nexus.nonNull(getContentTypeInputName(contentType2))
       },
-      async resolve(parent, args2, context) {
+      async resolve(parent, args22, context) {
         const { auth } = context.state;
-        const transformedArgs = transformArgs(args2, { contentType: contentType2 });
-        const sanitizedInputData = await utils$2.sanitize.contentAPI.input(
-          transformedArgs.data,
-          contentType2,
-          { auth }
-        );
-        Object.assign(transformedArgs, { data: sanitizedInputData });
-        const { update } = getService("builders").get("content-api").buildMutationsResolvers({ contentType: contentType2 });
-        const value = await update(parent, transformedArgs);
-        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+        const { data, documentId, ...restParams } = args22;
+        const sanitizedInputData = await utils$2.sanitize.contentAPI.input(data, contentType2, {
+          auth
+        });
+        return strapi2.documents(uid).update(documentId, {
+          ...restParams,
+          data: sanitizedInputData
+        });
       }
     });
   };
   const addDeleteMutation = (t, contentType2) => {
     const { uid } = contentType2;
     const deleteMutationName = getDeleteMutationTypeName(contentType2);
-    const responseTypeName = getEntityResponseName(contentType2);
+    const { DELETE_MUTATION_RESPONSE_TYPE_NAME: DELETE_MUTATION_RESPONSE_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
     t.field(deleteMutationName, {
-      type: responseTypeName,
+      type: DELETE_MUTATION_RESPONSE_TYPE_NAME2,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: {
-        // Query args
-        id: nexus.nonNull("ID")
-        // todo[v4]: Don't allow to filter using every unique attributes for now
-        // ...uniqueAttributes,
+        documentId: nexus.nonNull(nexus.idArg())
       },
-      async resolve(parent, args2, ctx) {
-        const transformedArgs = transformArgs(args2, { contentType: contentType2 });
-        const { delete: deleteResolver } = getService("builders").get("content-api").buildMutationsResolvers({ contentType: contentType2 });
-        const value = await deleteResolver(parent, args2, ctx);
-        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+      async resolve(parent, args22) {
+        const { documentId } = args22;
+        await strapi2.documents(uid).delete(documentId);
+        return { documentId };
       }
     });
   };
@@ -1975,70 +2128,67 @@ const { NotFoundError } = utils$2.errors;
 const createSingleTypeMutationsBuilder = ({ strapi: strapi2 }) => {
   const { service: getService } = strapi2.plugin("graphql");
   const { naming: naming2 } = getService("utils");
-  const { transformArgs } = getService("builders").utils;
-  const { toEntityResponse } = getService("format").returnTypes;
+  const { args: args2 } = getService("internals");
   const {
     getUpdateMutationTypeName,
-    getEntityResponseName,
+    getTypeName,
     getContentTypeInputName,
     getDeleteMutationTypeName
   } = naming2;
   const addUpdateMutation = (t, contentType2) => {
     const { uid } = contentType2;
     const updateMutationName = getUpdateMutationTypeName(contentType2);
-    const responseTypeName = getEntityResponseName(contentType2);
+    const typeName = getTypeName(contentType2);
     t.field(updateMutationName, {
-      type: responseTypeName,
+      type: typeName,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: {
         // Update payload
+        status: args2.PublicationStatusArg,
         data: nexus.nonNull(getContentTypeInputName(contentType2))
       },
-      async resolve(parent, args2, context) {
+      async resolve(parent, args22, context) {
         const { auth } = context.state;
-        const transformedArgs = transformArgs(args2, { contentType: contentType2 });
-        const sanitizedInputData = await utils$2.sanitize.contentAPI.input(
-          transformedArgs.data,
-          contentType2,
-          { auth }
-        );
-        Object.assign(transformedArgs, { data: sanitizedInputData });
-        const { create, update } = getService("builders").get("content-api").buildMutationsResolvers({ contentType: contentType2 });
-        await utils$2.validate.contentAPI.query(fp.omit(["data", "files"], transformedArgs), contentType2, {
+        const sanitizedInputData = await utils$2.sanitize.contentAPI.input(args22.data, contentType2, {
           auth
         });
-        const sanitizedQuery = await utils$2.sanitize.contentAPI.query(
-          fp.omit(["data", "files"], transformedArgs),
-          contentType2,
-          {
-            auth
-          }
-        );
-        const entity2 = await strapi2.entityService.findMany(uid, sanitizedQuery);
-        const value = fp.isNil(entity2) ? create(parent, transformedArgs) : update(uid, { id: entity2.id, data: transformedArgs.data });
-        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+        const document = await strapi2.db?.query(uid).findOne();
+        if (document) {
+          return strapi2.documents(uid).update(document.documentId, {
+            ...args22,
+            data: sanitizedInputData
+          });
+        }
+        return strapi2.documents(uid).create({
+          ...args22,
+          data: sanitizedInputData
+        });
       }
     });
   };
   const addDeleteMutation = (t, contentType2) => {
     const { uid } = contentType2;
     const deleteMutationName = getDeleteMutationTypeName(contentType2);
-    const responseTypeName = getEntityResponseName(contentType2);
+    const { DELETE_MUTATION_RESPONSE_TYPE_NAME: DELETE_MUTATION_RESPONSE_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
     t.field(deleteMutationName, {
-      type: responseTypeName,
+      type: DELETE_MUTATION_RESPONSE_TYPE_NAME2,
+      extensions: {
+        strapi: {
+          contentType: contentType2
+        }
+      },
       args: {},
-      async resolve(parent, args2, ctx) {
-        const transformedArgs = transformArgs(args2, { contentType: contentType2 });
-        const { delete: deleteResolver } = getService("builders").get("content-api").buildMutationsResolvers({ contentType: contentType2 });
-        await utils$2.validate.contentAPI.query(transformedArgs, contentType2, { auth: ctx?.state?.auth });
-        const sanitizedQuery = await utils$2.sanitize.contentAPI.query(transformedArgs, contentType2, {
-          auth: ctx?.state?.auth
-        });
-        const entity2 = await strapi2.entityService.findMany(uid, sanitizedQuery);
-        if (!entity2) {
-          throw new NotFoundError("Entity not found");
+      async resolve(parent, args22) {
+        const document = await strapi2.db?.query(uid).findOne();
+        if (!document) {
+          throw new NotFoundError("Document not found");
         }
-        const value = await deleteResolver(parent, { id: entity2.id, params: transformedArgs });
-        return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+        await strapi2.documents(uid).delete(document.documentId, args22);
+        return document;
       }
     });
   };
@@ -2125,9 +2275,9 @@ const contentType = ({ strapi: strapi2 }) => {
         const validAttributes = Object.entries(attributes2).filter(
           ([attributeName]) => extension.shadowCRUD(contentType2.uid).field(attributeName).hasFiltersEnabeld()
         );
-        const isIDFilterEnabled = extension.shadowCRUD(contentType2.uid).field("id").hasFiltersEnabeld();
+        const isIDFilterEnabled = extension.shadowCRUD(contentType2.uid).field("documentId").hasFiltersEnabeld();
         if (contentType2.kind === "collectionType" && isIDFilterEnabled) {
-          t.field("id", { type: getScalarFilterInputTypeName("ID") });
+          t.field("documentId", { type: getScalarFilterInputTypeName("ID") });
         }
         for (const [attributeName, attribute] of validAttributes) {
           if (isStrapiScalar(attribute)) {
@@ -2287,12 +2437,7 @@ const associationResolvers = ({ strapi: strapi2 }) => {
         const sanitizedQuery = await utils$2.sanitize.contentAPI.query(transformedArgs, targetContentType, {
           auth
         });
-        const data = await strapi2.entityService.load(
-          contentTypeUID,
-          parent,
-          attributeName,
-          sanitizedQuery
-        );
+        const data = await strapi2.db?.query(contentTypeUID).load(parent, attributeName, sanitizedQuery);
         const info = {
           args: sanitizedQuery,
           resourceUID: targetUID
@@ -2303,7 +2448,7 @@ const associationResolvers = ({ strapi: strapi2 }) => {
             return utils$2.sanitize.contentAPI.output(dataToSanitize, contentType2, { auth });
           };
           const unwrapData = fp.get(attributeName);
-          const sanitizeMorphAttribute = utils$2.pipeAsync(wrapData, sanitizeData, unwrapData);
+          const sanitizeMorphAttribute = utils$2.async.pipe(wrapData, sanitizeData, unwrapData);
           return sanitizeMorphAttribute(data);
         }
         if (isToMany) {
@@ -2318,49 +2463,35 @@ const queriesResolvers = ({ strapi: strapi2 }) => ({
   buildQueriesResolvers({ contentType: contentType2 }) {
     const { uid } = contentType2;
     return {
-      async find(parent, args2, ctx) {
+      async findMany(parent, args2, ctx) {
         await utils$2.validate.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
         const sanitizedQuery = await utils$2.sanitize.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
-        return strapi2.entityService.findMany(uid, sanitizedQuery);
+        return strapi2.documents(uid).findMany({ status: "published", ...sanitizedQuery });
       },
-      async findOne(parent, args2, ctx) {
+      async findFirst(parent, args2, ctx) {
         await utils$2.validate.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
         const sanitizedQuery = await utils$2.sanitize.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
-        return strapi2.entityService.findOne(uid, args2.id, fp.omit("id", sanitizedQuery));
-      }
-    };
-  }
-});
-const pickCreateArgs = fp.pick(["params", "data", "files"]);
-const mutationsResolvers = ({ strapi: strapi2 }) => ({
-  buildMutationsResolvers({ contentType: contentType2 }) {
-    const { uid } = contentType2;
-    return {
-      async create(parent, args2) {
-        const params = pickCreateArgs(args2);
-        return strapi2.entityService.create(uid, params);
-      },
-      async update(parent, args2) {
-        const { id, data } = args2;
-        return strapi2.entityService.update(uid, id, { data });
+        return strapi2.documents(uid).findFirst({ status: "published", ...sanitizedQuery });
       },
-      async delete(parent, args2, ctx) {
-        const { id, ...rest } = args2;
-        await utils$2.validate.contentAPI.query(rest, contentType2, {
+      async findOne(parent, args2, ctx) {
+        await utils$2.validate.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
-        const sanitizedQuery = await utils$2.sanitize.contentAPI.query(rest, contentType2, {
+        const sanitizedQuery = await utils$2.sanitize.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
-        return strapi2.entityService.delete(uid, id, sanitizedQuery);
+        return strapi2.documents(uid).findOne(args2.documentId, {
+          status: "published",
+          ...fp.omit(["id", "documentId"], sanitizedQuery)
+        });
       }
     };
   }
@@ -2382,7 +2513,7 @@ const componentResolvers = ({ strapi: strapi2 }) => ({
       const sanitizedQuery = await utils$2.sanitize.contentAPI.query(transformedArgs, component, {
         auth: ctx?.state?.auth
       });
-      return strapi2.entityService.load(contentTypeUID, parent, attributeName, sanitizedQuery);
+      return strapi2.db?.query(contentTypeUID).load(parent, attributeName, sanitizedQuery);
     };
   }
 });
@@ -2392,18 +2523,37 @@ const dynamicZoneResolvers = ({ strapi: strapi2 }) => ({
     attributeName
   }) {
     return async (parent) => {
-      return strapi2.entityService.load(contentTypeUID, parent, attributeName);
+      return strapi2.db?.query(contentTypeUID).load(parent, attributeName);
     };
   }
 });
+const paginationResolvers = ({ strapi: strapi2 }) => ({
+  async resolvePagination(parent, _, ctx) {
+    const { args: args2, resourceUID } = parent.info;
+    const { start, limit } = args2;
+    const safeLimit = Math.max(limit, 1);
+    const contentType2 = strapi2.getModel(resourceUID);
+    await utils$2.validate.contentAPI.query(args2, contentType2, {
+      auth: ctx?.state?.auth
+    });
+    const sanitizedQuery = await utils$2.sanitize.contentAPI.query(args2, contentType2, {
+      auth: ctx?.state?.auth
+    });
+    const total = await strapi2.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 };
+  }
+});
 const resolvers = (context) => ({
   // Generics
   ...associationResolvers(context),
   // Builders
-  ...mutationsResolvers(context),
   ...queriesResolvers(context),
   ...componentResolvers(context),
-  ...dynamicZoneResolvers(context)
+  ...dynamicZoneResolvers(context),
+  ...paginationResolvers(context)
 });
 const AND_FIELD_NAME = "and";
 const andOperator = () => ({
@@ -2619,18 +2769,10 @@ const operators = {
 };
 const operators$1 = ({ strapi: strapi2 }) => fp.mapValues((opCtor) => opCtor({ strapi: strapi2 }), operators);
 const { withDefaultPagination } = utils$2.pagination;
-const { hasDraftAndPublish } = utils$2.contentTypes;
 const utils = ({ strapi: strapi2 }) => {
   const { service: getService } = strapi2.plugin("graphql");
   return {
-    /**
-     * Get every args for a given content type
-     * @param {object} contentType
-     * @param {object} options
-     * @param {boolean} options.multiple
-     * @return {object}
-     */
-    getContentTypeArgs(contentType2, { multiple = true } = {}) {
+    getContentTypeArgs(contentType2, { multiple = true, isNested = false } = {}) {
       const { naming: naming2 } = getService("utils");
       const { args: args2 } = getService("internals");
       const { modelType } = contentType2;
@@ -2646,22 +2788,25 @@ const utils = ({ strapi: strapi2 }) => {
       const { kind } = contentType2;
       if (kind === "collectionType") {
         if (!multiple) {
-          return { id: "ID" };
+          return {
+            documentId: nexus.nonNull(nexus.idArg()),
+            status: args2.PublicationStatusArg
+          };
         }
         const params = {
           filters: naming2.getFiltersInputTypeName(contentType2),
           pagination: args2.PaginationArg,
           sort: args2.SortArg
         };
-        if (hasDraftAndPublish(contentType2)) {
-          Object.assign(params, { publicationState: args2.PublicationStateArg });
+        if (!isNested) {
+          Object.assign(params, { status: args2.PublicationStatusArg });
         }
         return params;
       }
       if (kind === "singleType") {
         const params = {};
-        if (hasDraftAndPublish(contentType2)) {
-          Object.assign(params, { publicationState: args2.PublicationStateArg });
+        if (!isNested) {
+          Object.assign(params, { status: args2.PublicationStatusArg });
         }
         return params;
       }
@@ -2726,7 +2871,6 @@ const buildersFactories = [
   enums,
   dynamicZone,
   entity,
-  entityMeta,
   typeBuilder,
   response,
   responseCollection,