Add ActorLoader & queries to handle both Users & SystemAgents

Author: CarsonF

src/components/user/actor.loader.ts

@@ -0,0 +1,15 @@
+import { ID } from '~/common';
+import { LoaderFactory, SessionAwareLoaderStrategy } from '~/core';
+import { Actor } from './dto';
+import { UserService } from './user.service';
+
+@LoaderFactory(() => Actor)
+export class ActorLoader extends SessionAwareLoaderStrategy<Actor> {
+  constructor(private readonly users: UserService) {
+    super();
+  }
+
+  async loadMany(ids: readonly ID[]) {
+    return await this.users.readManyActors(ids, this.session);
+  }
+}

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

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { NotImplementedException, PublicOf } from '~/common';
+import { ID, NotImplementedException, PublicOf } from '~/common';
 import { e, RepoFor, ScopeOf } from '~/core/edgedb';
 import {
   AssignOrganizationToUser,
@@ -9,13 +9,35 @@ import {
 } from './dto';
 import type { UserRepository } from './user.repository';
 
+const hydrateUser = e.shape(e.User, (user) => ({
+  ...user['*'],
+  __typename: e.str('User'),
+}));
+const hydrateSystemAgent = e.shape(e.SystemAgent, (agent) => ({
+  ...agent['*'],
+  __typename: e.str('SystemAgent'),
+}));
+
 @Injectable()
 export class UserEdgeDBRepository
-  extends RepoFor(User, {
-    hydrate: (user) => user['*'],
-  })
+  extends RepoFor(User, { hydrate: hydrateUser })
   implements PublicOf<UserRepository>
 {
+  async readManyActors(ids: readonly ID[]) {
+    const res = await this.db.run(this.readManyActorsQuery, { ids });
+    return [...res.users, ...res.agents];
+  }
+  private readonly readManyActorsQuery = e.params(
+    { ids: e.array(e.uuid) },
+    ({ ids }) => {
+      const actors = e.cast(e.Actor, e.array_unpack(ids));
+      return e.select({
+        users: e.select(actors.is(e.User), hydrateUser),
+        agents: e.select(actors.is(e.SystemAgent), hydrateSystemAgent),
+      });
+    },
+  );
+
   async doesEmailAddressExist(email: string) {
     const query = e.select(e.User, () => ({
       filter_single: { email },

src/components/user/user.module.ts

@@ -8,6 +8,7 @@ import { OrganizationModule } from '../organization/organization.module';
 import { PartnerModule } from '../partner/partner.module';
 import { TimeZoneModule } from '../timezone';
 import { ActorEdgeDBRepository } from './actor.edgedb.repository';
+import { ActorLoader } from './actor.loader';
 import { ActorNeo4jRepository } from './actor.neo4j.repository';
 import { ActorRepository } from './actor.repository';
 import { AssignableRolesResolver } from './assignable-roles.resolver';
@@ -39,6 +40,7 @@ import { UserService } from './user.service';
     UserResolver,
     AssignableRolesResolver,
     UserLoader,
+    ActorLoader,
     UserService,
     splitDb(UserRepository, UserEdgeDBRepository),
     KnownLanguageRepository,

src/components/user/user.repository.ts

@@ -29,6 +29,7 @@ import {
   AssignOrganizationToUser,
   CreatePerson,
   RemoveOrganizationFromUser,
+  SystemAgent,
   UpdateUser,
   User,
   UserListInput,
@@ -38,6 +39,25 @@ import {
 export class UserRepository extends DtoRepository<typeof User, [Session | ID]>(
   User,
 ) {
+  async readManyActors(ids: readonly ID[], session: Session) {
+    return await this.db
+      .query()
+      .raw('', { ids })
+      .matchNode('user', 'User')
+      .where({ 'user.id': inArray('ids', true) })
+      .apply(this.hydrate(session))
+      .union()
+      .matchNode('agent', 'SystemAgent')
+      .where({ 'agent.id': inArray('ids', true) })
+      .return<{ dto: UnsecuredDto<User | SystemAgent> }>(
+        merge('agent', {
+          __typename: '"SystemAgent"',
+        }).as('dto'),
+      )
+      .map('dto')
+      .run();
+  }
+
   private readonly roleProperties = (roles?: readonly Role[]) =>
     (roles || []).flatMap((role) =>
       property('roles', role, 'node', `role${role}`),
@@ -116,6 +136,7 @@ export class UserRepository extends DtoRepository<typeof User, [Session | ID]>(
         .match(requestingUser(requestingUserId))
         .return<{ dto: UnsecuredDto<User> }>(
           merge({ email: null }, 'props', {
+            __typename: '"User"',
             roles: 'roles',
             pinned: 'exists((requestingUser)-[:pinned]->(node))',
           }).as('dto'),

src/components/user/user.service.ts

@@ -29,6 +29,7 @@ import {
   CreatePerson,
   ModifyKnownLanguageArgs,
   RemoveOrganizationFromUser,
+  SystemAgent,
   UpdateUser,
   User,
   UserListInput,
@@ -86,6 +87,18 @@ export class UserService {
     return users.map((dto) => this.secure(dto, session));
   }
 
+  async readManyActors(
+    ids: readonly ID[],
+    session: Session,
+  ): Promise<ReadonlyArray<User | SystemAgent>> {
+    const users = await this.userRepo.readManyActors(ids, session);
+    return users.map((dto) =>
+      dto.__typename === 'User'
+        ? this.secure(dto, session)
+        : (dto as SystemAgent),
+    );
+  }
+
   secure(user: UnsecuredDto<User>, session: Session): User {
     return this.privileges.for(session, User).secure(user);
   }