V4 aggregation-grouping

[violabg]

Feature request

in V3 you had this feature

https://docs-v3.strapi.io/developer-docs/latest/development/plugins/graphql.html#aggregation-grouping

is this no longer possible in v4? do you have alternative?

Why is it needed?

I have a project that uses this functionality and would like to migrate in on v4 in the future.

[iicdii]

Aggregation-grouping is gone since MongoDB has been dropped in v4 - which was only available on Mongo database. Only root level aggregation is available now with pagination and meta. - I wrote an example below just in case to help you.
Alternatively, you can still implement it with customizing resolver.

# example query
query Categories(
  $filters: CategoryFiltersInput
  $pagination: PaginationArg
  $sort: [String]
  $publicationState: PublicationState
  $locale: I18NLocaleCode
) {
  categories(
    filters: $filters
    pagination: $pagination
    sort: $sort
    publicationState: $publicationState
    locale: $locale
  ) {
    data {
      id
    }
    meta {
      pagination {
        total
        page
        pageSize
        pageCount
      }
    }
  }
}

# example variables
{
  "filters": {},
  "pagination": {
    "start": 0,
    "limit": 5
  },
  "sort": [],
  "publicationState": null,
  "locale": "en"
}

[violabg]

thanks for replying,
but I'm using aggregation with groupBy in the latest version of v3, 3.6.8 whit postgres DB as following

  query GetTpEventsPerMonth(
    $startDate: Date
    $endDate: Date
    $user: [ID]
    $eventTypes: [ID]
    $eventCategory: [ID]
    $businessAreas: [ID]
    $country: String
    $sort: String
    $start: Int
    $limit: Int
  ) {
    tpEventsConnection(
      sort: $sort
      start: $start
      limit: $limit
      where: {
        _where: [
          { eventDateFrom_gte: $startDate, eventDateFrom_lte: $endDate }
          { businessAreas_in: $businessAreas }
          { eventCategory_in: $eventCategory }
          { user_in: $user }
          { eventTypes_in: $eventTypes }
          { country: $country }
        ]
      }
    ) {
      groupBy {
        eventDateFrom {
          key
          connection {
            values {
              ...EventFields
            }
          }
        }
      }
      aggregate {
        count
      }
    }
  }

  ${EVENT_FRAGMENTS}
`;

it would be nice to implement it, event with https://docs.strapi.io/developer-docs/latest/plugins/graphql.html#shadow-crud,
as you suggested but I can't figure it out how from docs.

strapi/documentation#535

[iicdii]

Yeah, I can't create custom query too.
Only solution I found to create custom query is using nexus.extendType, but when I try to query, it throws an error Forbidden access.

// src/index.js

module.exports = {
  register({ strapi }) {
    const { transformArgs, getContentTypeArgs } = strapi.plugin('graphql').service('builders').utils;
    const extensionService = strapi.plugin('graphql').service('extension');

    const extension = ({ nexus }) => ({
      types: [
        nexus.extendType({
          type: 'Query',
          definition(t) {
            t.field('eventConnection', {
              type: 'EventEntityResponseCollection',
              args: getContentTypeArgs(strapi.contentTypes['api::event.event']),
              async resolve(parent, args) {
                const transformedArgs = transformArgs(
                  args, { contentType: strapi.contentTypes['api::event.event'], usePagination: true }
                );

                const { find } = strapi
                  .plugin('graphql')
                  .service('builders')
                  .get('content-api')
                  .buildQueriesResolvers({ contentType: strapi.contentTypes['api::event.event'] });

                const nodes = await find(parent, transformedArgs);

                return nodes;
              },
            });
          },
        }),
      ],
    });
    extensionService.use(extension);
  },
};

Also I tried other typeDefs, resolvers, resolversConfig configs but it doesn't help me at all.
This is clearly issue.

[violabg]

Thanks for trying, I feel like there is still a big void in documenting how to customize graphql queries.
Normal considering they just released V4, but hope it will be improved soon.

[violabg]

I found a way to customise a query

"use strict";

module.exports = {
  /**
   * An asynchronous register function that runs before
   * your application is initialized.
   *
   * This gives you an opportunity to extend code.
   */
  register: ({ strapi }) => {
    const { transformArgs, getContentTypeArgs } = strapi
      .plugin("graphql")
      .service("builders").utils;
    const extensionService = strapi.plugin("graphql").service("extension");

    const extension = ({ nexus }) => ({
      // Nexus
      types: [
        nexus.extendType({
          type: "Query",
          definition: (t) => {
            t.field("greetings", {
              type: "String",
              args: { name: nexus.stringArg({ default: "World" }) },
              resolve: (root, args, ctx) => `Hello ${args.name}`
            });
          }
        }),
        nexus.extendType({
          type: "Query",
          definition(t) {
            t.field("findBySlug", {
              type: "RestaurantEntityResponse",
              args: { slug: nexus.stringArg() },
              async resolve(parent, args, ctx) {
                const transformedArgs = transformArgs(args, {
                  contentType:
                    strapi.contentTypes["api::restaurant.restaurant"],
                  usePagination: false
                });

                const { find } = strapi
                  .plugin("graphql")
                  .service("builders")
                  .get("content-api")
                  .buildQueriesResolvers({
                    contentType:
                      strapi.contentTypes["api::restaurant.restaurant"]
                  });

                const nodes = await find(parent, { filters: transformedArgs });

                if (nodes.length > 0) {
                  return {
                    value: nodes[0]
                  };
                } else {
                  throw new Error(ctx.koaContext.response.message);
                }
              }
            });
          }
        })
      ],

      resolversConfig: {
        "Query.greetings": {
          auth: false
        },
        "Query.findBySlug": {
          auth: false
        }
      }
    });

    extensionService.use(extension);
  },

  /**
   * An asynchronous bootstrap function that runs before
   * your application gets started.
   *
   * This gives you an opportunity to set up your data model,
   * run jobs, or perform some special logic.
   */
  bootstrap(/*{ strapi }*/) {}
};

this works too

"use strict";

module.exports = {
  /**
   * An asynchronous register function that runs before
   * your application is initialized.
   *
   * This gives you an opportunity to extend code.
   */
  register: ({ strapi }) => {
    const { transformArgs, getContentTypeArgs } = strapi
      .plugin("graphql")
      .service("builders").utils;
    const extensionService = strapi.plugin("graphql").service("extension");

    const extension = ({ nexus }) => ({
      // Nexus
      types: [
        nexus.extendType({
          type: "Query",
          definition: (t) => {
            t.field("greetings", {
              type: "String",
              args: { name: nexus.stringArg({ default: "World" }) },
              resolve: (root, args, ctx) => `Hello ${args.name}`
            });
          }
        }),
        nexus.extendType({
          type: "Query",
          definition(t) {
            t.field("findBySlug", {
              type: "RestaurantEntityResponse",
              args: { slug: nexus.stringArg() },
              async resolve(parent, args, ctx) {
                const transformedArgs = transformArgs(args, {
                  contentType:
                    strapi.contentTypes["api::restaurant.restaurant"],
                  usePagination: false
                });
                // console.log(`transformedArgs`, transformedArgs);

                const results = await strapi.entityService.findMany(
                  "api::restaurant.restaurant",
                  {
                    filters: transformedArgs
                  }
                );
                if (results.length > 0) {
                  return {
                    value: results[0]
                  };
                } else {
                  throw new Error(ctx.koaContext.response.message);
                }
              }
            });
          }
        })
      ],

      resolversConfig: {
        "Query.greetings": {
          auth: false
        },
        "Query.findBySlug": {
          auth: false
        }
      }
    });

    extensionService.use(extension);
  },

  /**
   * An asynchronous bootstrap function that runs before
   * your application gets started.
   *
   * This gives you an opportunity to set up your data model,
   * run jobs, or perform some special logic.
   */
  bootstrap(/*{ strapi }*/) {}
};

but I guess in order to have groupBy results you need to go with raw sql, there is no way to do it with strapi query API.

[violabg]

it would be nice to add a groupBy method on query api

https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/query-engine/bulk-operations.html#aggregations

in order to maintains the old functionality of V3
https://docs-v3.strapi.io/developer-docs/latest/development/plugins/graphql.html#aggregation-grouping

[iicdii]

Is auth: false always required? 🤔 It makes every custom query/mutation public, which is bad.
I think custom GraphQL query/mutation should come first before groupBy method.

We need to ask for advice from the GraphQL plugin maintainer. @Convly
Is there official/suggest way to extend custom query/mutation?

[violabg]

Is auth: false always required? 🤔 It makes every custom query/mutation public, which is bad.
I used false just for testing, I found on the docs that this can be customisable

// path: ./src/index.js

module.exports = {
  register({ strapi }) {
    const extensionService = strapi.plugin('graphql').service('extension');

    extensionService.use({
      resolversConfig: {
        'Query.categories': {
          /**
           * Querying the Categories content-type
           * bypasses the authorization system.
           */ 
          auth: false
        },
        'Query.restaurants': {
          /**
           * Querying the Restaurants content-type
           * requires the find permission
           * on the 'Address' content-type
           * of the 'Address' API
           */
          auth: {
            scope: ['api::address.address.find']
          }
        },
      }
    })
  }
}

but I agree with you that we should have an official/suggest way to extend custom query/mutation, I've already submit a request for it strapi/documentation#535

in this issue I'm more focused on aggregation-grouping

[iicdii]

I think they omit it because it's advanced feature. However I agree with having internal API for grouping is nice.
Currently building raw SQL seems only way to make it.

[Convly]

Hello 👋

Since we currently don't have those aggregations (groupBy, sum, etc...) implemented in the query engine, it would be kinda weird to try and implement it for GQL only. However, it's definitely something we want to bring back to Strapi & we'll start working on this when we'll have enough bandwidth.

Concerning the auth, we currently support auth: false, auth: 'scope', auth: ['scopeA', 'scopeB'] (as documented here), if you need more granular control on the authentication process, you can still use policies to restrict resolvers on specific conditions.

About the documentation on how to extend types & queries (well, the whole GQL documentation actually), I agree it should be more furnished and cover more usecases. We went through a lot of deep internal modifications on how GQL works in V4 and we had to iterate on the documentation each time, which didn't let us a lot of time to polish it.
I'll take some time this week and try to make it better. For this I would like to understand what are the main pain points you encountered, extending types? not menough examples? understanding the format? using nexus? the resolvers configuration (policies/middlewares/auth)?

[violabg]

thanks Convly,

For this I would like to understand what are the main pain points you encountered, extending types? not menough examples? understanding the format? using nexus? the resolvers configuration (policies/middlewares/auth)?

I guess

• extending types
• not enough examples

My goal was adding a custom method to GraphQL that could return an already existing Entity groupBy an attribute.
So in my case a new returned GraphQL type based on existing entity.

Since we don’t have the groupBy functionality, I went for an easier example, findBySlug, I didn't know how to extend the type, but thanks to iicdii I saw I could do it like this:

t.field("findBySlug", {
              type: "RestaurantEntityResponse",
              args: { slug: nexus.stringArg() },
              async resolve(parent, args, ctx) {

but there is not an official way in the doc, even regarding the resolve part I found that I can use:

async resolve(parent, args, ctx) {
                const transformedArgs = transformArgs(args, {
                  contentType:
                    strapi.contentTypes["api::restaurant.restaurant"],
                  usePagination: false
                });

                const { find } = strapi
                  .plugin("graphql")
                  .service("builders")
                  .get("content-api")
                  .buildQueriesResolvers({
                    contentType:
                      strapi.contentTypes["api::restaurant.restaurant"]
                  });

                const nodes = await find(parent, { filters: transformedArgs });

                if (nodes.length > 0) {
                  return {
                    value: nodes[0]
                  };
                } else {
                  throw new Error(ctx.koaContext.response.message);
                }
              }

or this

async resolve(parent, args, ctx) {
                const transformedArgs = transformArgs(args, {
                  contentType:
                    strapi.contentTypes["api::restaurant.restaurant"],
                  usePagination: false
                });
                // console.log(`transformedArgs`, transformedArgs);

                const results = await strapi.entityService.findMany(
                  "api::restaurant.restaurant",
                  {
                    filters: transformedArgs
                  }
                );
                if (results.length > 0) {
                  return {
                    value: results[0]
                  };
                } else {
                  throw new Error(ctx.koaContext.response.message);
                }
              }

is there a preferred way?
I personally feel is better to have the logic in the controllers/services, in order to share as much logic as possible between REST and GraphQL.
Do I need transformArgs? In my example doesn't seams to matter, so when should I use transformArgs?
How do we return error in GraphQL I used throw new Error(ctx.koaContext.response.message); by looking at console.log(ctx), but couldn't find an official way.