Add Contributor(s) Query

server/graphql/schemaV2.graphql

@@ -4244,6 +4244,11 @@
   collectiveSlug: String @deprecated(reason: "2024-08-26: Use account.slug instead")
   account: Account
 
+  """
+  List of accounts the contributor has contributed to
+  """
+  accountsContributedTo: [Account]
+
   """
   Contributor avatar or logo
   """
@@ -4715,6 +4720,11 @@
   """
   HOST_ADMIN
 
+  """
+  Not a Fiscal Host Admin
+  """
+  NON_HOST_ADMIN
+
   """
   Collective Admin
   """
@@ -14607,6 +14617,51 @@
     id: String!
   ): Conversation
 
+  """
+  Get Contributors grouped by their profiles
+  """
+  contributors(
+    """
+    Host hosting the account
+    """
+    account: AccountReferenceInput
+
+    """
+    Host hosting the account
+    """
+    host: AccountReferenceInput
+    limit: Int! = 100
+    offset: Int! = 0
+    role: [MemberRole]
+    type: [AccountType]
+
+    """
+    Admin only. To filter on the email address of a member, useful to check if a member exists.
+    """
+    email: EmailAddress
+
+    """
+    Order of the results
+    """
+    orderBy: ChronologicalOrderInput! = { field: CREATED_AT, direction: ASC }
+    includeInherited: Boolean = true
+  ): ContributorCollection!
+
+  """
+  Get Contributors grouped by their profiles
+  """
+  contributor(
+    """
+    Contributor Account reference
+    """
+    account: AccountReferenceInput
+
+    """
+    Context host to fetch the contributor from
+    """
+    host: AccountReferenceInput
+  ): Contributor!
+
   """
   Get exchange rates from Open Collective
   """
@@ -14928,6 +14983,36 @@
     """
     role: [MemberRole]
   ): [MemberInvitation]
+
+  """
+  Get all members (admins, members, backers, followers)
+  """
+  members(
+    """
+    Host hosting the account
+    """
+    account: AccountReferenceInput
+
+    """
+    Host hosting the account
+    """
+    host: AccountReferenceInput
+    limit: Int! = 100
+    offset: Int! = 0
+    role: [MemberRole]
+    accountType: [AccountType]
+
+    """
+    Admin only. To filter on the email address of a member, useful to check if a member exists.
+    """
+    email: EmailAddress
+
+    """
+    Order of the results
+    """
+    orderBy: ChronologicalOrderInput! = { field: CREATED_AT, direction: ASC }
+    includeInherited: Boolean = true
+  ): MemberCollection!
   order(
     """
     Identifiers to retrieve the Order

server/graphql/v2/interface/HasMembers.js

@@ -1,15 +1,10 @@
 import { GraphQLBoolean, GraphQLInt, GraphQLList, GraphQLNonNull } from 'graphql';
-import { intersection, isNil } from 'lodash';
 
-import { CollectiveType } from '../../../constants/collectives';
-import MemberRoles from '../../../constants/roles';
-import models, { Op, sequelize } from '../../../models';
-import { checkScope } from '../../common/scope-check';
-import { BadRequest } from '../../errors';
 import { GraphQLMemberCollection } from '../collection/MemberCollection';
-import { AccountTypeToModelMapping, GraphQLAccountType } from '../enum/AccountType';
+import { GraphQLAccountType } from '../enum/AccountType';
 import { GraphQLMemberRole } from '../enum/MemberRole';
 import { GraphQLChronologicalOrderInput } from '../input/ChronologicalOrderInput';
+import MembersCollectionQuery from '../query/collection/MembersCollectionQuery';
 import MemberInvitationsQuery from '../query/MemberInvitationsQuery';
 import EmailAddress from '../scalar/EmailAddress';
 
@@ -36,80 +31,8 @@ export const HasMembersFields = {
         defaultValue: true,
       },
     },
-    async resolve(collective, args, req) {
-      // Check Pagination arguments
-      if (isNil(args.limit) || args.limit < 0) {
-        args.limit = 100;
-      }
-      if (isNil(args.offset) || args.offset < 0) {
-        args.offset = 0;
-      }
-      if (args.limit > 1000 && !req.remoteUser?.isRoot()) {
-        throw new Error('Cannot fetch more than 1,000 members at the same time, please adjust the limit');
-      }
-
-      // TODO: isn't it a better practice to return null?
-      if (collective.isIncognito && (!req.remoteUser?.isAdmin(collective.id) || !checkScope(req, 'incognito'))) {
-        return { offset: args.offset, limit: args.limit, totalCount: 0, nodes: [] };
-      }
-
-      let where = { CollectiveId: collective.id };
-      const collectiveInclude = [];
-
-      if (args.role && args.role.length > 0) {
-        where.role = { [Op.in]: args.role };
-      }
-      const collectiveConditions = { deletedAt: null };
-      if (args.accountType && args.accountType.length > 0) {
-        collectiveConditions.type = {
-          [Op.in]: args.accountType.map(value => AccountTypeToModelMapping[value]),
-        };
-      }
-
-      // Inherit Accountants and Admin from parent collective for Events and Projects
-      if (args.includeInherited && [CollectiveType.EVENT, CollectiveType.PROJECT].includes(collective.type)) {
-        const inheritedRoles = [MemberRoles.ACCOUNTANT, MemberRoles.ADMIN, MemberRoles.MEMBER];
-        where = {
-          [Op.or]: [
-            where,
-            {
-              CollectiveId: collective.ParentCollectiveId,
-              role: { [Op.in]: args.role ? intersection(args.role, inheritedRoles) : inheritedRoles },
-            },
-          ],
-        };
-      }
-
-      if (args.email) {
-        if (!req.remoteUser?.isAdminOfCollective(collective)) {
-          throw new BadRequest('Only admins can lookup for members using the "email" argument');
-        } else {
-          collectiveInclude.push({ association: 'user', required: true, where: { email: args.email.toLowerCase() } });
-        }
-      }
-
-      const result = await models.Member.findAndCountAll({
-        where,
-        limit: args.limit,
-        offset: args.offset,
-        order: [[args.orderBy.field, args.orderBy.direction]],
-        attributes: {
-          include: [
-            [sequelize.literal(`"Member"."CollectiveId" = ${collective.ParentCollectiveId || 0}`), 'inherited'],
-          ],
-        },
-        include: [
-          {
-            model: models.Collective,
-            as: 'memberCollective',
-            where: collectiveConditions,
-            include: collectiveInclude,
-            required: true,
-          },
-        ],
-      });
-
-      return { nodes: result.rows, totalCount: result.count, limit: args.limit, offset: args.offset };
+    resolve(account, args, req) {
+      return MembersCollectionQuery.resolve(null, { ...args, account }, req);
     },
   },
   memberInvitations: MemberInvitationsQuery,

server/graphql/v2/object/Contributor.ts

@@ -88,6 +88,15 @@ export const GraphQLContributor = new GraphQLObjectType({
         return req.loaders.Collective.byId.load(contributor.id);
       },
     },
+    accountsContributedTo: {
+      type: new GraphQLList(GraphQLAccount),
+      description: 'List of accounts the contributor has contributed to',
+      resolve(contributor, _, req): Promise<Collective[]> {
+        return contributor.ContributedCollectiveIds
+          ? req.loaders.Collective.byId.loadMany(contributor.ContributedCollectiveIds)
+          : [];
+      },
+    },
     image: {
       type: GraphQLString,
       description: 'Contributor avatar or logo',

server/graphql/v2/query/ContributorQuery.ts

@@ -0,0 +1,34 @@
+import { GraphQLNonNull } from 'graphql';
+
+import { getHostContributorDetail } from '../../../lib/contributors';
+import { BadRequest } from '../../errors';
+import { fetchAccountWithReference, GraphQLAccountReferenceInput } from '../input/AccountReferenceInput';
+import { GraphQLContributor } from '../object/Contributor';
+
+const ContributorQuery = {
+  description: 'Get Contributors grouped by their profiles',
+  type: GraphQLContributor,
+  args: {
+    account: {
+      type: new GraphQLNonNull(GraphQLAccountReferenceInput),
+      description: 'Contributor Account reference',
+    },
+    host: {
+      type: new GraphQLNonNull(GraphQLAccountReferenceInput),
+      description: 'Context host to fetch the contributor from',
+    },
+  },
+  async resolve(_: void, args, req: Express.Request) {
+    const [account, host] = await Promise.all([
+      fetchAccountWithReference(args.account, { throwIfMissing: true }),
+      fetchAccountWithReference(args.host, { throwIfMissing: true }),
+    ]);
+    if (!req.remoteUser?.isAdminOfCollective(host)) {
+      throw new BadRequest('Only admins can lookup for members using the "host" argument');
+    }
+
+    return getHostContributorDetail(account.id, host.id);
+  },
+};
+
+export default ContributorQuery;

server/graphql/v2/query/collection/ContributorsCollectionQuery.ts

@@ -0,0 +1,103 @@
+import assert from 'assert';
+
+import { GraphQLInt, GraphQLList, GraphQLNonNull } from 'graphql';
+import { isNil } from 'lodash';
+
+import { countHostContributors, getHostContributors } from '../../../../lib/contributors';
+import { BadRequest } from '../../../errors';
+import { GraphQLContributorCollection } from '../../collection/ContributorCollection';
+import { AccountTypeToModelMapping, GraphQLAccountType } from '../../enum/AccountType';
+import { GraphQLMemberRole } from '../../enum/MemberRole';
+import { fetchAccountWithReference, GraphQLAccountReferenceInput } from '../../input/AccountReferenceInput';
+import EmailAddress from '../../scalar/EmailAddress';
+
+const DEFAULT_LIMIT = 100;
+
+const ContributorsCollectionQuery = {
+  description: 'Get Contributors grouped by their profiles',
+  type: new GraphQLNonNull(GraphQLContributorCollection),
+  args: {
+    account: {
+      type: GraphQLAccountReferenceInput,
+      description: 'Host hosting the account',
+    },
+    host: {
+      type: GraphQLAccountReferenceInput,
+      description: 'Host hosting the account',
+    },
+    role: { type: new GraphQLList(GraphQLMemberRole) },
+    type: { type: new GraphQLList(GraphQLAccountType) },
+    email: {
+      type: EmailAddress,
+      description: 'Admin only. To filter on the email address of a member, useful to check if a member exists.',
+    },
+    limit: { type: new GraphQLNonNull(GraphQLInt), defaultValue: DEFAULT_LIMIT },
+    offset: { type: new GraphQLNonNull(GraphQLInt), defaultValue: 0 },
+  },
+  async resolve(_: void, args, req: Express.Request) {
+    if (isNil(args.limit) || args.limit < 0) {
+      args.limit = DEFAULT_LIMIT;
+    }
+    if (isNil(args.offset) || args.offset < 0) {
+      args.offset = 0;
+    }
+    if (args.limit > DEFAULT_LIMIT && !req.remoteUser?.isRoot()) {
+      throw new Error(`Cannot fetch more than ${DEFAULT_LIMIT},members at the same time, please adjust the limit`);
+    }
+
+    assert(
+      Boolean(args.account) !== Boolean(args.host),
+      'You must provide either an account or a host to fetch the contributors',
+    );
+
+    const replacements: {
+      limit: number;
+      offset: number;
+      type?: string[];
+      role?: string[];
+      collectiveid?: number;
+      hostid?: number;
+      email?: string;
+    } = {
+      limit: args.limit,
+      offset: args.offset,
+    };
+
+    if (args.type && args.type.length > 0) {
+      replacements['type'] = args.type.map(value => AccountTypeToModelMapping[value]);
+    }
+
+    if (args.role && args.role.length > 0) {
+      replacements['role'] = args.role;
+    }
+
+    let account, host;
+    if (args.account) {
+      account = await fetchAccountWithReference(args.account, { throwIfMissing: true });
+      replacements['collectiveid'] = account.id;
+    }
+
+    if (args.host) {
+      host = await fetchAccountWithReference(args.host, { throwIfMissing: true });
+      if (!req.remoteUser?.isAdminOfCollective(host)) {
+        throw new BadRequest('Only admins can lookup for members using the "host" argument');
+      }
+      replacements['hostid'] = host.id;
+    }
+
+    if (args.email) {
+      if (req.remoteUser?.isAdminOfCollective(account) || req.remoteUser?.isAdminOfCollective(host)) {
+        replacements['email'] = args.email.toLowerCase();
+      } else {
+        throw new BadRequest('Only admins can lookup for members using the "email" argument');
+      }
+    }
+
+    const nodes = () => getHostContributors(replacements);
+    const totalCount = () => countHostContributors(replacements);
+
+    return { nodes, totalCount, limit: args.limit, offset: args.offset };
+  },
+};
+
+export default ContributorsCollectionQuery;