Merge pull request #2986 from SeedCompany/edgedb/repos

Author: CarsonF

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

@@ -117,7 +117,9 @@ export class ProjectMemberRepository extends DtoRepository<
           node('user', 'User'),
         ])
         .subQuery('user', (sub) =>
-          sub.with('user as node').apply(this.users.hydrate(session.userId)),
+          sub
+            .with('user as node')
+            .apply(this.users.hydrateAsNeo4j(session.userId)),
         )
         .return<{ dto: UnsecuredDto<ProjectMember> }>(
           merge('props', { user: 'dto' }).as('dto'),

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

@@ -1,90 +1,43 @@
 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 PublicOf<UserRepository>
+{
   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);
+  }
+  removeOrganizationFromUser(args: RemoveOrganizationFromUser): 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);
+  hydrateAsNeo4j(_session: unknown): any {
+    throw new NotImplementedException();
   }
 }

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),
     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,9 +100,11 @@ export class UserRepository extends DtoRepository<typeof User, [Session | ID]>(
     if (roles) {
       await this.updateRoles(existing, roles);
     }
+
+    return undefined;
   }
 
-  hydrate(requestingUserId: Session | ID) {
+  protected hydrate(requestingUserId: Session | ID) {
     return (query: Query) =>
       query
         .subQuery('node', (sub) =>
@@ -342,4 +347,8 @@ export class UserRepository extends DtoRepository<typeof User, [Session | ID]>(
       await removePrimary.first();
     }
   }
+
+  hydrateAsNeo4j(session: Session | ID) {
+    return this.hydrate(session);
+  }
 }

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;
   }
 

src/core/database/dto.repository.ts

@@ -18,7 +18,7 @@ import { DbTypeOf } from './db-type';
 import { OnIndex } from './indexer';
 import { matchProps } from './query';
 
-export const privileges = Symbol('DtoRepository.privileges');
+export const privileges = Symbol.for('DtoRepository.privileges');
 
 /**
  * A repository for a simple DTO. This provides a few methods out of the box.

src/core/edgedb/common.repository.ts

@@ -0,0 +1,76 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { EnhancedResource, ID, isIdLike, PublicOf } from '~/common';
+import type { CommonRepository as Neo4jCommonRepository } from '~/core/database';
+import { ResourceLike, ResourcesHost } from '~/core/resources/resources.host';
+import type { BaseNode } from '../database/results';
+import { EdgeDB } from './edgedb.service';
+import { e } from './reexports';
+
+/**
+ * This provides a few methods out of the box.
+ */
+@Injectable()
+export class CommonRepository implements PublicOf<Neo4jCommonRepository> {
+  @Inject(EdgeDB)
+  protected readonly db: EdgeDB;
+  @Inject(ResourcesHost)
+  protected readonly resources: ResourcesHost;
+
+  /**
+   * Here for compatibility with the Neo4j version.
+   * @deprecated this should be replaced with a different output shape,
+   * after we finish migration.
+   */
+  async getBaseNode(id: ID, fqn?: ResourceLike): Promise<BaseNode | undefined> {
+    const res = await this.getBaseNodes([id], fqn);
+    return res[0];
+  }
+
+  /**
+   * Here for compatibility with the Neo4j version.
+   * @deprecated this should be replaced with a different output shape,
+   * after we finish migration.
+   */
+  async getBaseNodes(
+    ids: readonly ID[],
+    fqn?: ResourceLike,
+  ): Promise<readonly BaseNode[]> {
+    const res = fqn
+      ? typeof fqn === 'string'
+        ? await this.resources.getByEdgeDB(fqn)
+        : EnhancedResource.of(fqn)
+      : undefined;
+    const query = e.params({ ids: e.array(e.uuid) }, ({ ids }) =>
+      e.select((res?.db ?? e.Object) as typeof e.Object, (obj) => ({
+        id: true,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        _typeFQN_: obj.__type__.name,
+        createdAt: obj.is(e.Mixin.Timestamped).createdAt,
+        filter: e.op(obj.id, 'in', e.array_unpack(ids)),
+      })),
+    );
+    const nodes = await this.db.run(query, { ids });
+
+    return await Promise.all(
+      nodes.map(async (node): Promise<BaseNode> => {
+        const res = await this.resources.getByEdgeDB(node._typeFQN_);
+        return {
+          identity: node.id,
+          labels: [res.dbLabel],
+          properties: {
+            id: node.id,
+            createdAt: node.createdAt,
+          },
+        };
+      }),
+    );
+  }
+
+  async deleteNode(objectOrId: { id: ID } | ID, _changeset?: ID) {
+    const id = isIdLike(objectOrId) ? objectOrId : objectOrId.id;
+    const query = e.delete(e.Object, () => ({
+      filter_single: { id },
+    }));
+    await this.db.run(query);
+  }
+}