Handle new director on swap already existing in projects

Author: CarsonF

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

@@ -110,12 +110,22 @@ export class ProjectMemberGelRepository
         },
       }));
       const replacements = e.for(inactivated.project, (project) =>
-        e.insert(e.Project.Member, {
-          project,
-          projectContext: project.projectContext,
-          user: newDirector,
-          roles: $.role,
-        }),
+        e
+          .insert(e.Project.Member, {
+            project,
+            projectContext: project.projectContext,
+            user: newDirector,
+            roles: $.role,
+          })
+          .unlessConflict((member) => ({
+            on: member.user,
+            else: e.update(member, () => ({
+              set: {
+                roles: { '+=': $.role },
+                inactiveAt: null,
+              },
+            })),
+          })),
       );
       return e.select({
         timestampId: e.datetime_of_transaction(),

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

@@ -1,5 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { type Node, node, type Query, relation } from 'cypher-query-builder';
+import {
+  type Node,
+  node,
+  not,
+  type Query,
+  relation,
+} from 'cypher-query-builder';
 import { DateTime } from 'luxon';
 import {
   CreationFailed,
@@ -13,13 +19,15 @@ import {
 import { DtoRepository } from '~/core/database';
 import {
   ACTIVE,
+  apoc,
   createNode,
   createRelationships,
   filter,
   matchPropsAndProjectSensAndScopedRoles,
   merge,
   oncePerProject,
   paginate,
+  path,
   randomUUID,
   sorting,
   updateProperty,
@@ -192,9 +200,22 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
     newDirector: ID<'User'>,
     role: Role,
   ) {
-    const now = DateTime.now();
+    const nowVal = DateTime.now();
+    const now = variable('$now');
+    const createMember = await createNode(ProjectMember, {
+      baseNodeProps: {
+        id: variable(randomUUID()),
+        createdAt: now,
+      },
+      initialProps: {
+        roles: [role],
+        inactiveAt: null,
+        modifiedAt: now,
+      },
+    });
     const result = await this.db
       .query()
+      .raw('', { now: nowVal })
       .match([
         node('project', 'Project'),
         relation('out', '', 'member', ACTIVE),
@@ -217,30 +238,81 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
         }),
       )
       .with('project')
-      .apply(
-        await createNode(ProjectMember, {
-          baseNodeProps: {
-            id: variable(randomUUID()),
-            createdAt: now,
-          },
-          initialProps: {
-            roles: [role],
-            inactiveAt: null,
-            modifiedAt: now,
-          },
-        }),
-      )
-      .apply(
-        createRelationships(ProjectMember, {
-          in: { member: variable('project') },
-          out: { user: ['User', newDirector] },
-        }),
+      .subQuery('project', (sub) =>
+        sub
+          .match([
+            [
+              node('project'),
+              relation('out', '', 'member', ACTIVE),
+              node('node', 'ProjectMember'),
+              relation('out', '', 'user', ACTIVE),
+              node('', 'User', { id: newDirector }),
+            ],
+            [
+              node('node', 'ProjectMember'),
+              relation('out', '', 'roles', ACTIVE),
+              node('roles', 'Property'),
+            ],
+          ])
+          .apply(
+            updateProperty({
+              resource: ProjectMember,
+              key: 'roles',
+              value: variable(apoc.coll.union('roles.value', [`"${role}"`])),
+              now,
+              permanentAfter: 0,
+              outputStatsVar: 'inactiveStats',
+            }),
+          )
+          .apply(
+            updateProperty({
+              resource: ProjectMember,
+              key: 'inactiveAt',
+              value: null,
+              now,
+              permanentAfter: 0,
+              outputStatsVar: 'rolesStats',
+            }),
+          )
+          .apply(
+            updateProperty({
+              resource: ProjectMember,
+              key: 'modifiedAt',
+              value: now,
+              now,
+              permanentAfter: 0,
+              outputStatsVar: 'modifiedAtStats',
+            }),
+          )
+          .return('node as member')
+          .union()
+          .with('project')
+          .with('project')
+          .where(
+            not(
+              path([
+                node('project'),
+                relation('out', '', 'member', ACTIVE),
+                node('', 'ProjectMember'),
+                relation('out', '', 'user', ACTIVE),
+                node('', 'User', { id: newDirector }),
+              ]),
+            ),
+          )
+          .apply(createMember)
+          .apply(
+            createRelationships(ProjectMember, {
+              in: { member: variable('project') },
+              out: { user: ['User', newDirector] },
+            }),
+          )
+          .return('node as member'),
       )
       .return<{ id: ID }>('project.id as id')
       .run();
     return {
       projects: result.map(({ id }) => id) as readonly ID[],
-      timestampId: now,
+      timestampId: nowVal,
     };
   }
 }

test/features/director-change-replaces-memberships-on-open-projects.e2e-spec.ts

@@ -75,6 +75,49 @@ it('director change replaces memberships on open projects', async () => {
       });
       return project;
     })(),
+    alreadyHasNewDirectorActive: await (async () => {
+      const project = await createProject(app);
+      await createProjectMember(app, {
+        projectId: project.id,
+        userId: directors.old.id,
+        roles: [Role.RegionalDirector],
+      });
+      await createProjectMember(app, {
+        projectId: project.id,
+        userId: directors.new.id,
+        roles: [Role.RegionalDirector],
+      });
+      return project;
+    })(),
+    alreadyHasNewDirectorInactive: await (async () => {
+      const project = await createProject(app);
+      await createProjectMember(app, {
+        projectId: project.id,
+        userId: directors.old.id,
+        roles: [Role.RegionalDirector],
+      });
+      await createProjectMember(app, {
+        projectId: project.id,
+        userId: directors.new.id,
+        roles: [Role.RegionalDirector],
+        inactiveAt: DateTime.now().plus({ minute: 1 }).toISO(),
+      });
+      return project;
+    })(),
+    alreadyHasNewDirectorWithoutRole: await (async () => {
+      const project = await createProject(app);
+      await createProjectMember(app, {
+        projectId: project.id,
+        userId: directors.old.id,
+        roles: [Role.RegionalDirector],
+      });
+      await createProjectMember(app, {
+        projectId: project.id,
+        userId: directors.new.id,
+        roles: [Role.ProjectManager],
+      });
+      return project;
+    })(),
     closed: await (async () => {
       const project = await createProject(app, {
         mouStart: '2025-06-05',
@@ -107,37 +150,82 @@ it('director change replaces memberships on open projects', async () => {
         app,
         projects.alreadyHasRoleFilled.id,
       ),
+      alreadyHasNewDirectorActive: await fetchMembers(
+        app,
+        projects.alreadyHasNewDirectorActive.id,
+      ),
+      alreadyHasNewDirectorInactive: await fetchMembers(
+        app,
+        projects.alreadyHasNewDirectorInactive.id,
+      ),
+      alreadyHasNewDirectorWithoutRole: await fetchMembers(
+        app,
+        projects.alreadyHasNewDirectorWithoutRole.id,
+      ),
       closed: await fetchMembers(app, projects.closed.id),
     };
+
     return {
-      get: (project: keyof typeof results, key: keyof typeof directors) =>
-        results[project].find(
+      get: (project: keyof typeof results, key: keyof typeof directors) => {
+        const member = results[project].find(
           (member) => member.user.value!.id === directors[key].id,
-        )?.active,
+        );
+        return member
+          ? {
+              active: member.active,
+              roles: member.roles.value,
+            }
+          : undefined;
+      },
     };
   };
   // endregion
 
   // region validate setup
   const before = await getResults();
 
-  expect(before.get('needsSwapA', 'old')).toBe(true);
+  const ActiveRD = { active: true, roles: ['RegionalDirector'] };
+  const InactiveRD = { active: false, roles: ['RegionalDirector'] };
+
+  expect(before.get('needsSwapA', 'old')).toEqual(ActiveRD);
   expect(before.get('needsSwapA', 'new')).toBeUndefined();
-  expect(before.get('needsSwapB', 'old')).toBe(true);
+  expect(before.get('needsSwapB', 'old')).toEqual(ActiveRD);
   expect(before.get('needsSwapB', 'new')).toBeUndefined();
 
   expect(before.get('needsSwapA', 'unrelated')).toBeUndefined();
   expect(before.get('needsSwapB', 'unrelated')).toBeUndefined();
   expect(before.get('doesNotHaveMember', 'old')).toBeUndefined();
   expect(before.get('doesNotHaveMember', 'new')).toBeUndefined();
   expect(before.get('doesNotHaveMember', 'unrelated')).toBeUndefined();
-  expect(before.get('hasMemberButInactive', 'old')).toBe(false);
+  expect(before.get('hasMemberButInactive', 'old')).toEqual(InactiveRD);
   expect(before.get('hasMemberButInactive', 'new')).toBeUndefined();
   expect(before.get('hasMemberButInactive', 'unrelated')).toBeUndefined();
   expect(before.get('alreadyHasRoleFilled', 'old')).toBeUndefined();
   expect(before.get('alreadyHasRoleFilled', 'new')).toBeUndefined();
-  expect(before.get('alreadyHasRoleFilled', 'unrelated')).toBe(true);
-  expect(before.get('closed', 'old')).toBe(true);
+  expect(before.get('alreadyHasRoleFilled', 'unrelated')).toEqual(ActiveRD);
+  expect(before.get('alreadyHasNewDirectorActive', 'old')).toEqual(ActiveRD);
+  expect(before.get('alreadyHasNewDirectorActive', 'new')).toEqual(ActiveRD);
+  expect(
+    before.get('alreadyHasNewDirectorActive', 'unrelated'),
+  ).toBeUndefined();
+  expect(before.get('alreadyHasNewDirectorInactive', 'old')).toEqual(ActiveRD);
+  expect(before.get('alreadyHasNewDirectorInactive', 'new')).toEqual(
+    InactiveRD,
+  );
+  expect(
+    before.get('alreadyHasNewDirectorInactive', 'unrelated'),
+  ).toBeUndefined();
+  expect(before.get('alreadyHasNewDirectorWithoutRole', 'old')).toEqual(
+    ActiveRD,
+  );
+  expect(before.get('alreadyHasNewDirectorWithoutRole', 'new')).toEqual({
+    active: true,
+    roles: [Role.ProjectManager],
+  });
+  expect(
+    before.get('alreadyHasNewDirectorWithoutRole', 'unrelated'),
+  ).toBeUndefined();
+  expect(before.get('closed', 'old')).toEqual(ActiveRD);
   expect(before.get('closed', 'new')).toBeUndefined();
   expect(before.get('closed', 'unrelated')).toBeUndefined();
   // endregion
@@ -163,23 +251,41 @@ it('director change replaces memberships on open projects', async () => {
   // region assertions
   const after = await getResults();
 
-  expect(after.get('needsSwapA', 'old')).toBe(false);
-  expect(after.get('needsSwapA', 'new')).toBe(true);
-  expect(after.get('needsSwapB', 'old')).toBe(false);
-  expect(after.get('needsSwapB', 'new')).toBe(true);
+  expect(after.get('needsSwapA', 'old')).toEqual(InactiveRD);
+  expect(after.get('needsSwapA', 'new')).toEqual(ActiveRD);
+  expect(after.get('needsSwapB', 'old')).toEqual(InactiveRD);
+  expect(after.get('needsSwapB', 'new')).toEqual(ActiveRD);
 
   expect(after.get('needsSwapA', 'unrelated')).toBeUndefined();
   expect(after.get('needsSwapB', 'unrelated')).toBeUndefined();
   expect(after.get('doesNotHaveMember', 'old')).toBeUndefined();
   expect(after.get('doesNotHaveMember', 'new')).toBeUndefined();
   expect(after.get('doesNotHaveMember', 'unrelated')).toBeUndefined();
-  expect(after.get('hasMemberButInactive', 'old')).toBe(false);
+  expect(after.get('hasMemberButInactive', 'old')).toEqual(InactiveRD);
   expect(after.get('hasMemberButInactive', 'new')).toBeUndefined();
   expect(after.get('hasMemberButInactive', 'unrelated')).toBeUndefined();
   expect(after.get('alreadyHasRoleFilled', 'old')).toBeUndefined();
   expect(after.get('alreadyHasRoleFilled', 'new')).toBeUndefined();
-  expect(after.get('alreadyHasRoleFilled', 'unrelated')).toBe(true);
-  expect(after.get('closed', 'old')).toBe(true);
+  expect(after.get('alreadyHasRoleFilled', 'unrelated')).toEqual(ActiveRD);
+  expect(after.get('alreadyHasNewDirectorActive', 'old')).toEqual(InactiveRD);
+  expect(after.get('alreadyHasNewDirectorActive', 'new')).toEqual(ActiveRD);
+  expect(after.get('alreadyHasNewDirectorActive', 'unrelated')).toBeUndefined();
+  expect(after.get('alreadyHasNewDirectorInactive', 'old')).toEqual(InactiveRD);
+  expect(after.get('alreadyHasNewDirectorInactive', 'new')).toEqual(ActiveRD);
+  expect(
+    after.get('alreadyHasNewDirectorInactive', 'unrelated'),
+  ).toBeUndefined();
+  expect(after.get('alreadyHasNewDirectorWithoutRole', 'old')).toEqual(
+    InactiveRD,
+  );
+  expect(after.get('alreadyHasNewDirectorWithoutRole', 'new')).toEqual({
+    active: true,
+    roles: [Role.ProjectManager, Role.RegionalDirector],
+  });
+  expect(
+    after.get('alreadyHasNewDirectorWithoutRole', 'unrelated'),
+  ).toBeUndefined();
+  expect(after.get('closed', 'old')).toEqual(ActiveRD);
   expect(after.get('closed', 'new')).toBeUndefined();
   expect(after.get('closed', 'unrelated')).toBeUndefined();
   // endregion
@@ -203,6 +309,9 @@ async function fetchMembers(app: TestApp, projectId: ID) {
                 inactiveAt {
                   value
                 }
+                roles {
+                  value
+                }
               }
             }
           }
@@ -211,5 +320,9 @@ async function fetchMembers(app: TestApp, projectId: ID) {
     ),
     { projectId },
   );
-  return res.project.team.items;
+  const members = res.project.team.items;
+  if (members.length !== new Set(members.map((m) => m.user.value!.id)).size) {
+    throw new Error('Duplicate members detected');
+  }
+  return members;
 }