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

package/dist/server/index.mjs

@@ -1,13 +1,16 @@
-import { isEmpty, toUpper, snakeCase, pick, mergeWith, isArray, propOr, get, getOr, first, isFunction, isNil, prop, startsWith, difference, propEq, isDate, isObject, has, mapValues, map, upperFirst, camelCase, pipe, lowerFirst, set, omit, identity, constant, isUndefined, isString, defaultTo, entries, reduce, merge as merge$1 } from "lodash/fp";
-import { ForbiddenError as ForbiddenError$2, UserInputError, ApolloError, ApolloServer } from "apollo-server-koa";
-import { ApolloServerPluginLandingPageDisabled, ApolloServerPluginLandingPageGraphQLPlayground } from "apollo-server-core";
+import { isEmpty, toUpper, snakeCase, pick, mergeWith, isArray, isObject, propOr, get, getOr, first, isFunction, isNil, prop, startsWith, difference, propEq, isDate, has, mapValues, map, upperFirst, camelCase, pipe, lowerFirst, set, omit, identity, constant, isUndefined, isString, defaultTo, entries, reduce, merge as merge$1 } from "lodash/fp";
+import { ApolloServer } from "@apollo/server";
+import { ApolloServerPluginLandingPageLocalDefault, ApolloServerPluginLandingPageProductionDefault } from "@apollo/server/plugin/landingPage/default";
+import { koaMiddleware } from "@as-integrations/koa";
 import depthLimit from "graphql-depth-limit";
-import { graphqlUploadKoa, GraphQLUpload } from "graphql-upload";
-import { errors, policy, parseType, validate, sanitize, toRegressedEnumValue, contentTypes, pipeAsync, pagination as pagination$1 } from "@strapi/utils";
+import bodyParser from "koa-bodyparser";
+import cors from "@koa/cors";
+import { errors, policy, parseType, strings, contentTypes, sanitize, validate, async, pagination as pagination$1 } from "@strapi/utils";
+import { unwrapResolverError } from "@apollo/server/errors";
 import { GraphQLError, GraphQLObjectType, GraphQLScalarType, Kind, valueFromASTUntyped } from "graphql";
 import { pruneSchema } from "@graphql-tools/utils";
 import * as nexus from "nexus";
-import { unionType, makeSchema, arg, list, inputObjectType, asNexusMethod, objectType, enumType, scalarType, nonNull, extendType } from "nexus";
+import { unionType, makeSchema, arg, list, inputObjectType, asNexusMethod, objectType, enumType, scalarType, nonNull, extendType, idArg } from "nexus";
 import { singular } from "pluralize";
 import { GraphQLDate, GraphQLJSON, GraphQLDateTime, GraphQLLong } from "graphql-scalars";
 const defaultConfig = {
@@ -15,7 +18,8 @@ const defaultConfig = {
   endpoint: "/graphql",
   subscriptions: false,
   maxLimit: -1,
-  apolloServer: {}
+  apolloServer: {},
+  v4CompatibilityMode: process.env.STRAPI_GRAPHQL_V4_COMPATIBILITY_MODE ?? false
 };
 const config = {
   default: defaultConfig
@@ -25,41 +29,49 @@ const formatToCode = (name) => `STRAPI_${toUpper(snakeCase(name))}`;
 const formatErrorToExtension = (error2) => ({
   error: 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 GraphQLError(message, options);
+}
+function formatGraphqlError(formattedError, error2) {
+  const originalError = unwrapResolverError(error2);
   if (isEmpty(originalError)) {
-    return error2;
+    return formattedError;
   }
+  const { message = "", name = "UNKNOWN" } = originalError;
   if (originalError instanceof ForbiddenError$1 || originalError instanceof UnauthorizedError) {
-    return new ForbiddenError$2(originalError.message, formatErrorToExtension(originalError));
+    return createFormattedError(formattedError, message, "FORBIDDEN", originalError);
   }
   if (originalError instanceof ValidationError$3) {
-    return new 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 ApolloError(originalError.message, name, formatErrorToExtension(originalError));
+    const errorName = formatToCode(name);
+    return createFormattedError(formattedError, message, errorName, originalError);
   }
-  if (originalError instanceof ApolloError || originalError instanceof GraphQLError) {
-    return error2;
+  if (originalError instanceof GraphQLError) {
+    return formattedError;
   }
   strapi.log.error(originalError);
-  return new ApolloError("Internal Server Error", "INTERNAL_SERVER_ERROR");
+  return createFormattedError(
+    new GraphQLError("Internal Server Error"),
+    "Internal Server Error",
+    "INTERNAL_SERVER_ERROR",
+    originalError
+  );
 }
 const merge = mergeWith((a, b) => {
   if (isArray(a) && isArray(b)) {
     return a.concat(b);
   }
 });
-const useUploadMiddleware = (strapi2, path) => {
-  const uploadMiddleware = 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 (isEmpty(schema)) {
@@ -68,14 +80,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 = ApolloServerPluginLandingPageLocalDefault();
+    strapi2.log.debug("Using Apollo sandbox landing page");
+  } else {
+    landingPage = 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(config2("depthLimit"))],
     // Errors
@@ -84,14 +100,16 @@ async function bootstrap({ strapi: strapi2 }) {
     cors: false,
     uploads: false,
     bodyParserConfig: true,
-    plugins: [
-      process.env.NODE_ENV === "production" && !config2("playgroundAlways") ? ApolloServerPluginLandingPageDisabled() : 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 serverConfig = merge(
+    defaultServerConfig,
+    config2("apolloServer")
+  );
   const server = new ApolloServer(serverConfig);
-  useUploadMiddleware(strapi2, path);
   try {
     await server.start();
   } catch (error2) {
@@ -100,29 +118,43 @@ async function bootstrap({ strapi: strapi2 }) {
     }
     throw error2;
   }
+  const handler = [];
+  if (cors) {
+    handler.push(cors());
+  }
+  if (isObject(serverConfig.bodyParserConfig)) {
+    handler.push(bodyParser(serverConfig.bodyParserConfig));
+  } else if (serverConfig.bodyParserConfig) {
+    handler.push(bodyParser());
+  } 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(
+    koaMiddleware(server, {
+      // 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
       }
@@ -433,7 +465,7 @@ const registerInternals = ({ registry, strapi: strapi2 }) => {
     registry.registerMany(Object.entries(definitions), { kind });
   }
 };
-const registerDynamicZonesDefinition$1 = (contentType2, {
+const registerDynamicZonesDefinition = (contentType2, {
   registry,
   strapi: strapi2,
   builders: builders2
@@ -462,7 +494,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
@@ -489,7 +521,7 @@ const registerEnumsDefinition$1 = (contentType2, {
     });
   }
 };
-const registerInputsDefinition$1 = (contentType2, {
+const registerInputsDefinition = (contentType2, {
   registry,
   strapi: strapi2,
   builders: builders2
@@ -505,7 +537,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
@@ -517,18 +549,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");
@@ -715,7 +735,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) => {
@@ -929,6 +949,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",
@@ -966,16 +989,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 = [
@@ -1096,7 +1129,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,
@@ -1110,11 +1144,11 @@ const SortArg = arg({
   type: 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 arg({
-    type: PUBLICATION_STATE_TYPE_NAME2,
-    default: "live"
+    type: PUBLICATION_STATUS_TYPE_NAME2,
+    default: "published"
   });
 };
 const PaginationInputType = inputObjectType({
@@ -1133,7 +1167,7 @@ const PaginationArg = arg({
 const args = (context) => ({
   SortArg,
   PaginationArg,
-  PublicationStateArg: publicationState$1(context)
+  PublicationStatusArg: publicationStatus$1(context)
 });
 const { ValidationError: ValidationError$2 } = errors;
 const TimeScalar = new GraphQLScalarType({
@@ -1167,8 +1201,7 @@ const scalars = () => ({
   DateTime: asNexusMethod(GraphQLDateTime, "dateTime"),
   Time: asNexusMethod(TimeScalar, "time"),
   Date: asNexusMethod(GraphQLDate, "date"),
-  Long: asNexusMethod(GraphQLLong, "long"),
-  Upload: asNexusMethod(GraphQLUpload, "upload")
+  Long: asNexusMethod(GraphQLLong, "long")
 });
 const pagination = ({ strapi: strapi2 }) => {
   const { PAGINATION_TYPE_NAME: PAGINATION_TYPE_NAME2 } = strapi2.plugin("graphql").service("constants");
@@ -1189,7 +1222,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
@@ -1199,44 +1233,38 @@ const buildResponseCollectionMeta = ({ strapi: strapi2 }) => {
     ResponseCollectionMeta: 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 validate.contentAPI.query(args2, contentType2, {
-              auth: ctx?.state?.auth
-            });
-            const sanitizedQuery = await 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: 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: enumType({
-      name: PUBLICATION_STATE_TYPE_NAME2,
+    PublicationStatus: enumType({
+      name: PUBLICATION_STATUS_TYPE_NAME2,
       members: {
-        // Published only
-        LIVE: "live",
-        // Published & draft
-        PREVIEW: "preview"
+        DRAFT: "draft",
+        PUBLISHED: "published"
       }
     })
   };
@@ -1293,10 +1321,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)
@@ -1320,7 +1349,7 @@ const buildEnumTypeDefinition = (definition, name) => {
   return enumType({
     name,
     members: definition.enum.reduce(
-      (acc, value) => set(toRegressedEnumValue(value), value, acc),
+      (acc, value) => set(strings.toRegressedEnumValue(value), value, acc),
       {}
     )
   });
@@ -1426,11 +1455,6 @@ const entity = ({ strapi: strapi2 }) => {
     }
   };
 };
-function buildEntityMetaDefinition() {
-}
-const entityMeta = () => ({
-  buildEntityMetaDefinition
-});
 const typeBuilder = (context) => {
   const { strapi: strapi2 } = context;
   const getGraphQLService = strapi2.plugin("graphql").service;
@@ -1457,7 +1481,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) => {
@@ -1506,9 +1533,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: nonNull(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");
@@ -1553,12 +1603,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: nonNull(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 !contentTypes.isPrivateAttribute(contentType2, attributeName);
@@ -1593,9 +1669,29 @@ const typeBuilder = (context) => {
       return 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;
@@ -1638,12 +1734,12 @@ const response = ({ strapi: strapi2 }) => {
      */
     buildResponseDefinition(contentType2) {
       const name = naming2.getEntityResponseName(contentType2);
-      const entityName = naming2.getEntityName(contentType2);
+      const typeName = naming2.getTypeName(contentType2);
       return objectType({
         name,
         definition(t) {
           t.field("data", {
-            type: entityName,
+            type: typeName,
             resolve: prop("value")
           });
         }
@@ -1652,8 +1748,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
@@ -1662,19 +1759,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 objectType({
         name,
         definition(t) {
-          t.nonNull.list.field("data", {
-            type: nonNull(entityName),
+          t.nonNull.list.field("nodes", {
+            type: nonNull(typeName),
             resolve: pipe(prop("nodes"), defaultTo([]))
           });
-          t.nonNull.field("meta", {
-            type: RESPONSE_COLLECTION_META_TYPE_NAME2,
-            // Pass down the args stored in the source object
-            resolve: 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: nonNull(typeName),
+              resolve: pipe(prop("nodes"), defaultTo([]))
+            });
+            t.nonNull.field("meta", {
+              deprecation: "Use the `pageInfo` field instead",
+              type: RESPONSE_COLLECTION_META_TYPE_NAME2,
+              resolve: identity
+            });
+          }
         }
       });
     }
@@ -1688,14 +1797,21 @@ const relationResponseCollection = ({ strapi: strapi2 }) => {
      */
     buildRelationResponseCollectionDefinition(contentType2) {
       const name = naming2.getRelationResponseCollectionName(contentType2);
-      const entityName = naming2.getEntityName(contentType2);
+      const typeName = naming2.getTypeName(contentType2);
       return objectType({
         name,
         definition(t) {
-          t.nonNull.list.field("data", {
-            type: nonNull(entityName),
+          t.nonNull.list.field("nodes", {
+            type: nonNull(typeName),
             resolve: pipe(prop("nodes"), defaultTo([]))
           });
+          if (strapi2.plugin("graphql").config("v4CompatibilityMode", false)) {
+            t.nonNull.list.field("data", {
+              deprecation: "Use `nodes` field instead",
+              type: nonNull(typeName),
+              resolve: pipe(prop("nodes"), defaultTo([]))
+            });
+          }
         }
       });
     }
@@ -1705,16 +1821,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 } } });
@@ -1729,6 +1847,7 @@ const createCollectionTypeQueriesBuilder = ({ strapi: strapi2 }) => {
     }
     if (isFindEnabled) {
       registerAuthConfig(findQueryName, { scope: [`${contentType2.uid}.find`] });
+      registerAuthConfig(findConnectionQueryName, { scope: [`${contentType2.uid}.find`] });
     }
     return extendType({
       type: "Query",
@@ -1737,37 +1856,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: nonNull(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 });
       }
     });
@@ -1778,8 +1924,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");
@@ -1803,17 +1948,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);
       }
     });
   };
@@ -1826,86 +1974,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: 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 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 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: nonNull("ID"),
-        // todo[v4]: Don't allow to filter using every unique attributes for now
-        // ...uniqueAttributes,
-        // Update payload
+        documentId: nonNull(idArg()),
+        status: args2.PublicationStatusArg,
         data: 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 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 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: nonNull("ID")
-        // todo[v4]: Don't allow to filter using every unique attributes for now
-        // ...uniqueAttributes,
+        documentId: nonNull(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 };
       }
     });
   };
@@ -1954,70 +2105,67 @@ const { NotFoundError } = 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: 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 sanitize.contentAPI.input(
-          transformedArgs.data,
-          contentType2,
-          { auth }
-        );
-        Object.assign(transformedArgs, { data: sanitizedInputData });
-        const { create, update } = getService("builders").get("content-api").buildMutationsResolvers({ contentType: contentType2 });
-        await validate.contentAPI.query(omit(["data", "files"], transformedArgs), contentType2, {
+        const sanitizedInputData = await sanitize.contentAPI.input(args22.data, contentType2, {
           auth
         });
-        const sanitizedQuery = await sanitize.contentAPI.query(
-          omit(["data", "files"], transformedArgs),
-          contentType2,
-          {
-            auth
-          }
-        );
-        const entity2 = await strapi2.entityService.findMany(uid, sanitizedQuery);
-        const value = 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 validate.contentAPI.query(transformedArgs, contentType2, { auth: ctx?.state?.auth });
-        const sanitizedQuery = await 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;
       }
     });
   };
@@ -2104,9 +2252,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)) {
@@ -2266,12 +2414,7 @@ const associationResolvers = ({ strapi: strapi2 }) => {
         const sanitizedQuery = await 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
@@ -2282,7 +2425,7 @@ const associationResolvers = ({ strapi: strapi2 }) => {
             return sanitize.contentAPI.output(dataToSanitize, contentType2, { auth });
           };
           const unwrapData = get(attributeName);
-          const sanitizeMorphAttribute = pipeAsync(wrapData, sanitizeData, unwrapData);
+          const sanitizeMorphAttribute = async.pipe(wrapData, sanitizeData, unwrapData);
           return sanitizeMorphAttribute(data);
         }
         if (isToMany) {
@@ -2297,49 +2440,35 @@ const queriesResolvers = ({ strapi: strapi2 }) => ({
   buildQueriesResolvers({ contentType: contentType2 }) {
     const { uid } = contentType2;
     return {
-      async find(parent, args2, ctx) {
+      async findMany(parent, args2, ctx) {
         await validate.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
         const sanitizedQuery = await 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 validate.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
         const sanitizedQuery = await sanitize.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
-        return strapi2.entityService.findOne(uid, args2.id, omit("id", sanitizedQuery));
-      }
-    };
-  }
-});
-const pickCreateArgs = 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 validate.contentAPI.query(rest, contentType2, {
+      async findOne(parent, args2, ctx) {
+        await validate.contentAPI.query(args2, contentType2, {
           auth: ctx?.state?.auth
         });
-        const sanitizedQuery = await sanitize.contentAPI.query(rest, contentType2, {
+        const sanitizedQuery = await 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",
+          ...omit(["id", "documentId"], sanitizedQuery)
+        });
       }
     };
   }
@@ -2361,7 +2490,7 @@ const componentResolvers = ({ strapi: strapi2 }) => ({
       const sanitizedQuery = await 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);
     };
   }
 });
@@ -2371,18 +2500,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 validate.contentAPI.query(args2, contentType2, {
+      auth: ctx?.state?.auth
+    });
+    const sanitizedQuery = await 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 = () => ({
@@ -2598,18 +2746,10 @@ const operators = {
 };
 const operators$1 = ({ strapi: strapi2 }) => mapValues((opCtor) => opCtor({ strapi: strapi2 }), operators);
 const { withDefaultPagination } = pagination$1;
-const { hasDraftAndPublish } = 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;
@@ -2625,22 +2765,25 @@ const utils = ({ strapi: strapi2 }) => {
       const { kind } = contentType2;
       if (kind === "collectionType") {
         if (!multiple) {
-          return { id: "ID" };
+          return {
+            documentId: nonNull(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;
       }
@@ -2705,7 +2848,6 @@ const buildersFactories = [
   enums,
   dynamicZone,
   entity,
-  entityMeta,
   typeBuilder,
   response,
   responseCollection,