Change User EdgeDB Repo to extend from new EdgeDB Dto Repo

Author: CarsonF

src/components/user/user.edgedb.repository.ts

@@ -1,90 +1,46 @@
 import { Injectable } from '@nestjs/common';
-import { ID, NotFoundException, Session } from '~/common';
-import { e, EdgeDB } from '~/core/edgedb';
-import { CreatePerson, User, UserListInput } from './dto';
-import { UserRepository } from './user.repository';
-
-const hydrate = e.shape(e.User, (user) => ({
-  ...user['*'],
-  // Other links if needed
-}));
+import { NotImplementedException, PublicOf } from '~/common';
+import { e, RepoFor, ScopeOf } from '~/core/edgedb';
+import {
+  AssignOrganizationToUser,
+  RemoveOrganizationFromUser,
+  User,
+  UserListInput,
+} from './dto';
+import type { UserRepository } from './user.repository';
 
 @Injectable()
-export class UserEdgedbRepository extends UserRepository {
-  constructor(private readonly edgedb: EdgeDB) {
-    super();
-  }
-
-  async readOne(id: ID, _session: Session | ID) {
-    const query = e.select(e.User, (user) => ({
-      ...hydrate(user),
-      filter_single: { id },
-    }));
-    const user = await this.edgedb.run(query);
-    if (!user) {
-      throw new NotFoundException('Could not find user');
-    }
-    return user;
-  }
-
-  async readMany(ids: readonly ID[], _session: Session | ID) {
-    const query = e.params({ ids: e.array(e.uuid) }, ({ ids }) =>
-      e.select(e.User, (user) => ({
-        ...hydrate(user),
-        filter: e.op(user.id, 'in', e.array_unpack(ids)),
-      })),
-    );
-    const users = await this.edgedb.run(query, { ids });
-    return users;
-  }
-
+export class UserEdgeDBRepository
+  extends RepoFor(User).withDefaults()
+  implements
+    Omit<
+      PublicOf<UserRepository>,
+      // hydrate is public (not default) and specific to Neo4j,
+      // but it will only be called by other neo4j repositories,
+      // so it doesn't have to match here
+      'hydrate'
+    >
+{
   async doesEmailAddressExist(email: string) {
     const query = e.select(e.User, () => ({
       filter_single: { email },
     }));
-    const result = await this.edgedb.run(query);
+    const result = await this.db.run(query);
     return !!result;
   }
 
-  async list(input: UserListInput, _session: Session) {
-    const sortKey = input.sort as keyof (typeof e.User)['*'];
-    const all = e.select(e.User, (user) => ({
-      filter: e.all(
-        input.filter.pinned != null
-          ? e.op(user.pinned, '=', input.filter.pinned)
-          : true,
-        // More filters here when needed...
-      ),
-      order_by: {
-        expression: user[sortKey],
-        direction: input.order,
-      },
-    }));
-    const thisPage = e.select(all, () => ({
-      offset: (input.page - 1) * input.count,
-      limit: input.count + 1,
-    }));
-    const query = e.select({
-      items: e.select(thisPage, (user) => ({
-        ...hydrate(user),
-        limit: input.count,
-      })),
-      total: e.count(all),
-      hasMore: e.op(e.count(thisPage), '>', input.count),
-    });
-    return await this.edgedb.run(query);
+  protected listFilters(user: ScopeOf<typeof e.User>, input: UserListInput) {
+    return [
+      input.filter.pinned != null &&
+        e.op(user.pinned, '=', input.filter.pinned),
+      // More filters here when needed...
+    ];
   }
 
-  async create(input: CreatePerson) {
-    const query = e.insert(e.User, { ...input });
-    const result = await this.edgedb.run(query);
-    return result.id;
+  assignOrganizationToUser(args: AssignOrganizationToUser): Promise<void> {
+    throw new NotImplementedException().with(args);
   }
-
-  async delete(id: ID, _session: Session, _object: User): Promise<void> {
-    const query = e.delete(e.User, () => ({
-      filter_single: { id },
-    }));
-    await this.edgedb.run(query);
+  removeOrganizationFromUser(args: RemoveOrganizationFromUser): Promise<void> {
+    throw new NotImplementedException().with(args);
   }
 }

src/components/user/user.module.ts

@@ -12,7 +12,7 @@ import { EducationModule } from './education/education.module';
 import { KnownLanguageRepository } from './known-language.repository';
 import { KnownLanguageResolver } from './known-language.resolver';
 import { UnavailabilityModule } from './unavailability/unavailability.module';
-import { UserEdgedbRepository } from './user.edgedb.repository';
+import { UserEdgeDBRepository } from './user.edgedb.repository';
 import { UserLoader } from './user.loader';
 import { UserRepository } from './user.repository';
 import { UserResolver } from './user.resolver';
@@ -36,7 +36,7 @@ import { UserService } from './user.service';
     AssignableRolesResolver,
     UserLoader,
     UserService,
-    splitDb(UserRepository, UserEdgedbRepository),
+    splitDb(UserRepository, UserEdgeDBRepository as any),
     KnownLanguageRepository,
   ],
   exports: [UserService, UserRepository, EducationModule, UnavailabilityModule],

src/components/user/user.repository.ts

@@ -84,10 +84,13 @@ export class UserRepository extends DtoRepository<typeof User, [Session | ID]>(
     if (!result) {
       throw new ServerException('Failed to create user');
     }
-    return result.id;
+    return result;
   }
 
-  async update(existing: User, changes: ChangesOf<User, UpdateUser>) {
+  async update(
+    existing: User,
+    changes: ChangesOf<User, UpdateUser>,
+  ): Promise<unknown> {
     const { roles, email, ...simpleChanges } = changes;
 
     await this.updateProperties(existing, simpleChanges);
@@ -97,6 +100,8 @@ export class UserRepository extends DtoRepository<typeof User, [Session | ID]>(
     if (roles) {
       await this.updateRoles(existing, roles);
     }
+
+    return undefined;
   }
 
   hydrate(requestingUserId: Session | ID) {

src/components/user/user.service.ts

@@ -79,7 +79,7 @@ export class UserService {
       this.verifyRolesAreAssignable(session, input.roles);
     }
 
-    const id = await this.userRepo.create(input);
+    const { id } = await this.userRepo.create(input);
     return id;
   }