[EdgeDB] Project Member queries

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

@@ -0,0 +1,52 @@
+import { Injectable } from '@nestjs/common';
+import { isIdLike, PublicOf } from '~/common';
+import { e, RepoFor, ScopeOf } from '~/core/edgedb';
+import {
+  CreateProjectMember,
+  ProjectMember,
+  ProjectMemberListInput,
+} from './dto';
+import { ProjectMemberRepository as Neo4jRepository } from './project-member.repository';
+
+@Injectable()
+export class ProjectMemberEdgeDBRepository
+  extends RepoFor(ProjectMember, {
+    hydrate: (member) => ({
+      ...member['*'],
+      user: member.user['*'],
+    }),
+    omit: ['create'],
+  })
+  implements PublicOf<Neo4jRepository>
+{
+  async create({ projectId: projectOrId, userId, roles }: CreateProjectMember) {
+    const projectId = isIdLike(projectOrId) ? projectOrId : projectOrId.id;
+    const project = e.cast(e.Project, e.uuid(projectId));
+
+    const created = e.insert(this.resource.db, {
+      user: e.cast(e.User, e.uuid(userId)),
+      project,
+      projectContext: project.projectContext,
+      roles,
+    });
+    const query = e.select(created, this.hydrate);
+    return await this.db.run(query);
+  }
+
+  protected listFilters(
+    member: ScopeOf<typeof e.Project.Member>,
+    { filter: input }: ProjectMemberListInput,
+  ) {
+    return [
+      (input.roles?.length ?? 0) > 0 &&
+        e.op(
+          'exists',
+          e.op(
+            member.roles,
+            'intersect',
+            e.cast(e.Role, e.set(...input.roles!)),
+          ),
+        ),
+    ];
+  }
+}

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

@@ -1,7 +1,9 @@
 import { forwardRef, Module } from '@nestjs/common';
+import { splitDb } from '~/core';
 import { AuthorizationModule } from '../../authorization/authorization.module';
 import { UserModule } from '../../user/user.module';
 import { ProjectModule } from '../project.module';
+import { ProjectMemberEdgeDBRepository } from './project-member.edgedb.repository';
 import { ProjectMemberLoader } from './project-member.loader';
 import { ProjectMemberRepository } from './project-member.repository';
 import { ProjectMemberResolver } from './project-member.resolver';
@@ -16,7 +18,7 @@ import { ProjectMemberService } from './project-member.service';
   providers: [
     ProjectMemberResolver,
     ProjectMemberService,
-    ProjectMemberRepository,
+    splitDb(ProjectMemberRepository, ProjectMemberEdgeDBRepository),
     ProjectMemberLoader,
   ],
   exports: [ProjectMemberService],

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

@@ -1,19 +1,27 @@
 import { Injectable } from '@nestjs/common';
 import { Node, node, Query, relation } from 'cypher-query-builder';
 import { DateTime } from 'luxon';
-import { ChangesOf } from '~/core/database/changes';
-import { ID, Session, UnsecuredDto } from '../../../common';
-import { DtoRepository } from '../../../core';
+import {
+  DuplicateException,
+  ID,
+  isIdLike,
+  NotFoundException,
+  ServerException,
+  Session,
+  UnsecuredDto,
+} from '~/common';
+import { DtoRepository } from '~/core/database';
 import {
   ACTIVE,
+  createNode,
+  createRelationships,
   matchPropsAndProjectSensAndScopedRoles,
   merge,
   oncePerProject,
   paginate,
-  property,
   requestingUser,
   sorting,
-} from '../../../core/database/query';
+} from '~/core/database/query';
 import { UserRepository } from '../../user/user.repository';
 import {
   CreateProjectMember,
@@ -31,8 +39,8 @@ export class ProjectMemberRepository extends DtoRepository<
     super();
   }
 
-  async verifyRelationshipEligibility(projectId: ID, userId: ID) {
-    return await this.db
+  private async verifyRelationshipEligibility(projectId: ID, userId: ID) {
+    const result = await this.db
       .query()
       .optionalMatch(node('user', 'User', { id: userId }))
       .optionalMatch(node('project', 'Project', { id: projectId }))
@@ -43,63 +51,69 @@ export class ProjectMemberRepository extends DtoRepository<
         relation('out', '', 'user', ACTIVE),
         node('user'),
       ])
-      .return(['user', 'project', 'member'])
-      .asResult<{ user?: Node; project?: Node; member?: Node }>()
+      .return<{ user?: Node; project?: Node; member?: Node }>([
+        'user',
+        'project',
+        'member',
+      ])
       .first();
+
+    if (!result?.project) {
+      throw new NotFoundException(
+        'Could not find project',
+        'projectMember.projectId',
+      );
+    }
+    if (!result?.user) {
+      throw new NotFoundException(
+        'Could not find person',
+        'projectMember.userId',
+      );
+    }
+    if (result.member) {
+      throw new DuplicateException(
+        'projectMember.userId',
+        'Person is already a member of this project',
+      );
+    }
   }
 
   async create(
-    { userId, projectId, ...input }: CreateProjectMember,
-    id: ID,
+    { userId, projectId: projectOrId, ...input }: CreateProjectMember,
     session: Session,
-    createdAt: DateTime,
   ) {
-    const createProjectMember = this.db
-      .query()
-      .create([
-        [
-          node('newProjectMember', 'ProjectMember:BaseNode', {
-            createdAt,
-            id,
-          }),
-        ],
-        ...property('roles', input.roles, 'newProjectMember'),
-        ...property('modifiedAt', createdAt, 'newProjectMember'),
-      ])
-      .return<{ id: ID }>('newProjectMember.id as id');
-    await createProjectMember.first();
+    const projectId = isIdLike(projectOrId) ? projectOrId : projectOrId.id;
+
+    await this.verifyRelationshipEligibility(projectId, userId);
 
-    // connect the Project to the ProjectMember
-    // and connect ProjectMember to User
-    return await this.db
+    const created = await this.db
       .query()
-      .match([
-        [node('user', 'User', { id: userId })],
-        [node('project', 'Project', { id: projectId })],
-        [node('projectMember', 'ProjectMember', { id })],
-      ])
-      .create([
-        node('project'),
-        relation('out', '', 'member', {
-          active: true,
-          createdAt: DateTime.local(),
+      .apply(
+        await createNode(ProjectMember, {
+          initialProps: {
+            roles: input.roles ?? [],
+            modifiedAt: DateTime.local(),
+          },
         }),
-        node('projectMember'),
-        relation('out', '', 'user', {
-          active: true,
-          createdAt: DateTime.local(),
+      )
+      .apply(
+        createRelationships(ProjectMember, {
+          in: { member: ['Project', projectId] },
+          out: { user: ['User', userId] },
         }),
-        node('user'),
-      ])
-      .return<{ id: ID }>('projectMember.id as id')
+      )
+      .apply(this.hydrate(session))
+      .map('dto')
       .first();
+    if (!created) {
+      throw new ServerException('Failed to create project member');
+    }
+    return created;
   }
 
-  async update(
-    existing: ProjectMember,
-    changes: ChangesOf<ProjectMember, UpdateProjectMember>,
-  ) {
-    await this.updateProperties(existing, changes);
+  async update({ id, ...changes }: UpdateProjectMember, session: Session) {
+    await this.updateProperties({ id }, changes);
+    return await this.readOne(id, session);
   }
 
   protected hydrate(session: Session) {