Merge pull request #3446 from SeedCompany/membership-filters

Author: CarsonF

src/components/engagement/dto/list-engagements.dto.ts

@@ -45,7 +45,6 @@ export abstract class EngagementFilters {
   })
   readonly status?: readonly EngagementStatus[];
 
-  readonly projectId?: ID;
   @FilterField(() => ProjectFilters)
   readonly project?: ProjectFilters & {};
 

src/components/engagement/engagement.repository.ts

@@ -496,18 +496,24 @@ export class EngagementRepository extends CommonRepository {
       .subQuery((sub) =>
         sub
           .match([
-            node('project', 'Project', pickBy({ id: input.filter?.projectId })),
+            node(
+              'project',
+              'Project',
+              pickBy({ id: input.filter?.project?.id }),
+            ),
             relation('out', '', 'engagement', ACTIVE),
             node('node', 'Engagement'),
           ])
           .apply(whereNotDeletedInChangeset(changeset))
           .return(['node', 'project'])
           .apply((q) =>
-            changeset && input.filter?.projectId
+            changeset && input.filter?.project?.id
               ? q
                   .union()
                   .match([
-                    node('project', 'Project', { id: input.filter.projectId }),
+                    node('project', 'Project', {
+                      id: input.filter.project?.id,
+                    }),
                     relation('out', '', 'engagement', INACTIVE),
                     node('node', 'Engagement'),
                     relation('in', '', 'changeset', ACTIVE),
@@ -739,11 +745,6 @@ export const engagementFilters = filter.define(() => EngagementFilters, {
     ),
   }),
   status: filter.stringListProp(),
-  projectId: filter.pathExists((id) => [
-    node('node'),
-    relation('in', '', 'engagement'),
-    node('project', 'Project', { id }),
-  ]),
   partnerId: filter.pathExists((id) => [
     node('node'),
     relation('in', '', 'engagement'),

src/components/project/dto/list-projects.dto.ts

@@ -16,6 +16,7 @@ import {
 } from '~/common';
 import { LocationFilters } from '../../location/dto';
 import { PartnershipFilters } from '../../partnership/dto';
+import { ProjectMemberFilters } from '../project-member/dto';
 import { ProjectStatus } from './project-status.enum';
 import { ProjectStep } from './project-step.enum';
 import { ProjectType } from './project-type.enum';
@@ -28,6 +29,8 @@ import {
 
 @InputType()
 export abstract class ProjectFilters {
+  readonly id?: ID<'Project'>;
+
   @OptionalField()
   readonly name?: string;
 
@@ -96,6 +99,17 @@ export abstract class ProjectFilters {
   })
   readonly isMember?: boolean;
 
+  @FilterField(() => ProjectMemberFilters, {
+    description:
+      "Only projects with the requesting user's membership that matches these filters",
+  })
+  readonly membership?: ProjectMemberFilters & {};
+
+  @FilterField(() => ProjectMemberFilters, {
+    description: 'Only projects with _any_ members matching these filters',
+  })
+  readonly members?: ProjectMemberFilters & {};
+
   @OptionalField({
     description: 'Filter for projects with two or more engagements.',
   })

src/components/project/project-filters.query.ts

@@ -16,9 +16,11 @@ import {
 import { locationFilters } from '../location/location.repository';
 import { partnershipFilters } from '../partnership/partnership.repository';
 import { ProjectFilters } from './dto';
+import { projectMemberFilters } from './project-member/project-member.repository';
 import { ProjectNameIndex } from './project.repository';
 
 export const projectFilters = filter.define(() => ProjectFilters, {
+  id: filter.baseNodeProp(),
   type: filter.stringListBaseNodeProp(),
   pinned: filter.isPinned,
   status: filter.stringListProp(),
@@ -32,7 +34,7 @@ export const projectFilters = filter.define(() => ProjectFilters, {
     currentUser,
     relation('in', '', 'user'),
     node('', 'ProjectMember'),
-    relation('in', '', 'member'),
+    relation('in', '', 'member', ACTIVE),
     node('node'),
   ]),
   languageId: filter.pathExists((id) => [
@@ -53,9 +55,25 @@ export const projectFilters = filter.define(() => ProjectFilters, {
     currentUser,
     relation('in', '', 'user'),
     node('', 'ProjectMember'),
-    relation('in', '', 'member'),
+    relation('in', '', 'member', ACTIVE),
     node('node'),
   ]),
+  membership: filter.sub(() => projectMemberFilters)((sub) =>
+    sub.match([
+      currentUser,
+      relation('in', '', 'user'),
+      node('node', 'ProjectMember'),
+      relation('in', '', 'member', ACTIVE),
+      node('outer'),
+    ]),
+  ),
+  members: filter.sub(() => projectMemberFilters)((sub) =>
+    sub.match([
+      node('node', 'ProjectMember'),
+      relation('in', '', 'member', ACTIVE),
+      node('outer'),
+    ]),
+  ),
   userId: ({ value }) => ({
     userId: [
       // TODO We can leak if the project includes this person, if the

src/components/project/project-member/dto/list-project-members.dto.ts

@@ -1,13 +1,15 @@
 import { InputType, ObjectType } from '@nestjs/graphql';
 import {
   FilterField,
-  type ID,
   ListField,
+  OptionalField,
   PaginatedList,
   Role,
   SecuredList,
   SortablePaginationInput,
 } from '~/common';
+import { UserFilters } from '../../../user/dto';
+import { ProjectFilters } from '../../dto';
 import { ProjectMember } from './project-member.dto';
 
 @InputType()
@@ -19,7 +21,14 @@ export abstract class ProjectMemberFilters {
   })
   readonly roles?: readonly Role[];
 
-  readonly projectId?: ID;
+  @OptionalField()
+  readonly active?: boolean;
+
+  @FilterField(() => ProjectFilters)
+  readonly project?: ProjectFilters & {};
+
+  @FilterField(() => UserFilters)
+  readonly user?: UserFilters & {};
 }
 
 @InputType()

src/components/project/project-member/project-member.repository.ts

@@ -15,16 +15,21 @@ import {
   ACTIVE,
   createNode,
   createRelationships,
+  filter,
   matchPropsAndProjectSensAndScopedRoles,
   merge,
   oncePerProject,
   paginate,
   sorting,
 } from '~/core/database/query';
-import { UserRepository } from '../../user/user.repository';
+import { type FilterFn } from '~/core/database/query/filters';
+import { userFilters, UserRepository } from '../../user/user.repository';
+import { type ProjectFilters } from '../dto';
+import { projectFilters } from '../project-filters.query';
 import {
   type CreateProjectMember,
   ProjectMember,
+  ProjectMemberFilters,
   type ProjectMemberListInput,
   type UpdateProjectMember,
 } from './dto';
@@ -140,28 +145,11 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
     const result = await this.db
       .query()
       .match([
-        node(
-          'project',
-          'Project',
-          filter?.projectId ? { id: filter.projectId } : {},
-        ),
+        node('project', 'Project'),
         relation('out', '', 'member'),
         node('node', 'ProjectMember'),
       ])
-      .apply((q) =>
-        filter?.roles
-          ? q
-              .match([
-                node('node'),
-                relation('out', '', 'roles', ACTIVE),
-                node('role', 'Property'),
-              ])
-              .raw(
-                `WHERE size(apoc.coll.intersection(role.value, $filteredRoles)) > 0`,
-                { filteredRoles: filter.roles },
-              )
-          : q,
-      )
+      .apply(projectMemberFilters(filter))
       .with('*') // needed between where & where
       .apply(
         this.privileges.filterToReadable({
@@ -174,30 +162,15 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
     return result!; // result from paginate() will always have 1 row.
   }
 
-  async listAsNotifiers(projectId: ID, roles?: Role[]) {
+  async listAsNotifiers(project: ID<'Project'>, roles?: Role[]) {
     return await this.db
       .query()
       .match([
-        node('', 'Project', { id: projectId }),
-        relation('out', '', 'member', ACTIVE),
         node('node', 'ProjectMember'),
         relation('out', '', 'user', ACTIVE),
         node('user', 'User'),
       ])
-      .apply((q) =>
-        roles
-          ? q
-              .match([
-                node('node'),
-                relation('out', '', 'roles', ACTIVE),
-                node('role', 'Property'),
-              ])
-              .raw(
-                `WHERE size(apoc.coll.intersection(role.value, $filteredRoles)) > 0`,
-                { filteredRoles: roles },
-              )
-          : q,
-      )
+      .apply(projectMemberFilters({ project: { id: project }, roles }))
       .with('user')
       .optionalMatch([
         node('user'),
@@ -211,3 +184,22 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
       .run();
   }
 }
+
+export const projectMemberFilters = filter.define(() => ProjectMemberFilters, {
+  project: filter.sub((): FilterFn<ProjectFilters> => projectFilters)((sub) =>
+    sub.match([
+      node('node', 'Project'),
+      relation('out', '', 'member', ACTIVE),
+      node('outer'),
+    ]),
+  ),
+  user: filter.sub(() => userFilters)((sub) =>
+    sub.match([
+      node('outer'),
+      relation('out', '', 'user'),
+      node('node', 'User'),
+    ]),
+  ),
+  roles: filter.intersectsProp(),
+  active: filter.isPropNotNull('inactiveAt'),
+});

src/components/project/project.service.ts

@@ -354,7 +354,10 @@ export class ProjectService {
         ...input,
         filter: {
           ...input.filter,
-          projectId: project.id,
+          project: {
+            id: project.id,
+            ...input.filter?.project,
+          },
         },
       },
       view,
@@ -379,7 +382,10 @@ export class ProjectService {
       ...input,
       filter: {
         ...input.filter,
-        projectId: project.id,
+        project: {
+          id: project.id,
+          ...input.filter?.project,
+        },
       },
     });
 

src/components/user/dto/list-users.dto.ts

@@ -1,6 +1,7 @@
 import { InputType, ObjectType } from '@nestjs/graphql';
 import {
   FilterField,
+  type ID,
   ListField,
   OptionalField,
   PaginatedList,
@@ -11,6 +12,8 @@ import { User } from './user.dto';
 
 @InputType()
 export abstract class UserFilters {
+  readonly id?: ID<'User'>;
+
   @OptionalField()
   readonly name?: string;
 

src/components/user/user.repository.ts

@@ -389,6 +389,7 @@ export class UserRepository extends DtoRepository(User) {
 }
 
 export const userFilters = filter.define(() => UserFilters, {
+  id: filter.baseNodeProp(),
   pinned: filter.isPinned,
   name: filter.fullText({
     index: () => NameIndex,

src/core/database/query/filters.ts

@@ -50,10 +50,14 @@ export const define =
   <T extends Record<string, any>>(
     filterClass: () => AbstractClass<T>,
     builders: Builders<T>,
-  ) =>
-  (filters: T | Nil) =>
+  ): FilterFn<T> =>
+  (filters) =>
     builder(filters ?? {}, builders);
 
+export type FilterFn<T extends Record<string, any>> = (
+  filters: T | Nil,
+) => (query: Query) => void;
+
 /**
  * A helper to split filters given and call their respective functions.
  * Functions can do nothing, adjust query, return an object to add conditions to
@@ -108,6 +112,10 @@ export const propVal =
     return { [prop ?? key]: cond };
   };
 
+export const baseNodeProp =
+  <T>(prop?: string): Builder<T> =>
+  ({ key, value }) => ({ [`node.${prop ?? key}`]: value });
+
 export const propPartialVal =
   <T, K extends ConditionalKeys<Required<T>, string>>(
     prop?: string,