[EdgeDB] Create Field Region queries (#3052)

Author: bryanjnelson

src/components/field-region/dto/field-region.dto.ts

@@ -1,18 +1,17 @@
 import { ObjectType } from '@nestjs/graphql';
 import { keys as keysOf } from 'ts-transformer-keys';
-import { e } from '~/core/edgedb';
-import { RegisterResource } from '~/core/resources';
 import {
   DbUnique,
-  ID,
   NameField,
   Resource,
   Secured,
   SecuredProperty,
   SecuredPropertyList,
   SecuredProps,
   SecuredString,
-} from '../../../common';
+} from '~/common';
+import { e } from '~/core/edgedb';
+import { LinkTo, RegisterResource } from '~/core/resources';
 
 @RegisterResource()
 @ObjectType({
@@ -27,9 +26,9 @@ export class FieldRegion extends Resource {
   @DbUnique()
   readonly name: SecuredString;
 
-  readonly fieldZone: Secured<ID>;
+  readonly fieldZone: Secured<LinkTo<'FieldZone'>>;
 
-  readonly director: Secured<ID>;
+  readonly director: Secured<LinkTo<'User'>>;
 }
 
 @ObjectType({

src/components/field-region/field-region.edgedb.repository.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@nestjs/common';
+import { PublicOf } from '../../common';
+import { ChangesOf } from '../../core/database/changes';
+import { e, RepoFor } from '../../core/edgedb';
+import { CreateFieldRegion, FieldRegion, UpdateFieldRegion } from './dto';
+import { FieldRegionRepository } from './field-region.repository';
+
+@Injectable()
+export class FieldRegionEdgeDBRepository
+  extends RepoFor(FieldRegion, {
+    hydrate: (region) => ({
+      ...region['*'],
+      director: true,
+      fieldZone: true,
+    }),
+  }).customize((cls) => {
+    return class extends cls {
+      async create(input: CreateFieldRegion) {
+        const created = e.insert(e.FieldRegion, {
+          name: input.name,
+          director: e.cast(e.User, e.cast(e.uuid, input.directorId)),
+          fieldZone: e.cast(e.FieldZone, e.cast(e.uuid, input.fieldZoneId)),
+        });
+        const query = e.select(created, this.hydrate);
+        return await this.db.run(query);
+      }
+
+      async update(
+        { id }: Pick<FieldRegion, 'id'>,
+        changes: ChangesOf<FieldRegion, UpdateFieldRegion>,
+      ) {
+        const region = e.cast(e.FieldRegion, e.cast(e.uuid, id));
+        const updated = e.update(region, () => ({
+          set: {
+            ...(changes.name && { name: changes.name }),
+            ...(changes.directorId && {
+              director: e.cast(e.User, e.cast(e.uuid, changes.directorId)),
+            }),
+            ...(changes.fieldZoneId && {
+              fieldZone: e.cast(
+                e.FieldZone,
+                e.cast(e.uuid, changes.fieldZoneId),
+              ),
+            }),
+          },
+        }));
+        const query = e.select(updated, this.hydrate);
+        return await this.db.run(query);
+      }
+    };
+  })
+  implements PublicOf<FieldRegionRepository> {}

src/components/field-region/field-region.module.ts

@@ -1,7 +1,9 @@
 import { forwardRef, Module } from '@nestjs/common';
+import { splitDb } from '~/core';
 import { AuthorizationModule } from '../authorization/authorization.module';
 import { FieldZoneModule } from '../field-zone/field-zone.module';
 import { UserModule } from '../user/user.module';
+import { FieldRegionEdgeDBRepository } from './field-region.edgedb.repository';
 import { FieldRegionLoader } from './field-region.loader';
 import { FieldRegionRepository } from './field-region.repository';
 import { FieldRegionResolver } from './field-region.resolver';
@@ -16,7 +18,7 @@ import { FieldRegionService } from './field-region.service';
   providers: [
     FieldRegionResolver,
     FieldRegionService,
-    FieldRegionRepository,
+    splitDb(FieldRegionRepository, FieldRegionEdgeDBRepository),
     FieldRegionLoader,
   ],
   exports: [FieldRegionService],

src/components/field-region/field-region.repository.ts

@@ -1,8 +1,15 @@
 import { Injectable } from '@nestjs/common';
 import { node, Query, relation } from 'cypher-query-builder';
+import {
+  DuplicateException,
+  ID,
+  SecuredList,
+  ServerException,
+  Session,
+  UnsecuredDto,
+} from '~/common';
+import { DtoRepository } from '~/core';
 import { ChangesOf } from '~/core/database/changes';
-import { ID, Session, UnsecuredDto } from '../../common';
-import { DtoRepository } from '../../core';
 import {
   ACTIVE,
   createNode,
@@ -13,7 +20,7 @@ import {
   paginate,
   requestingUser,
   sorting,
-} from '../../core/database/query';
+} from '~/core/database/query';
 import {
   CreateFieldRegion,
   FieldRegion,
@@ -24,6 +31,13 @@ import {
 @Injectable()
 export class FieldRegionRepository extends DtoRepository(FieldRegion) {
   async create(input: CreateFieldRegion, session: Session) {
+    if (!(await this.isUnique(input.name))) {
+      throw new DuplicateException(
+        'fieldRegion.name',
+        'FieldRegion with this name already exists.',
+      );
+    }
+
     const initialProps = {
       name: input.name,
       canDelete: true,
@@ -42,20 +56,31 @@ export class FieldRegionRepository extends DtoRepository(FieldRegion) {
       )
       .return<{ id: ID }>('node.id as id');
 
-    return await query.first();
+    const result = await query.first();
+    if (!result) {
+      throw new ServerException('failed to create field region');
+    }
+
+    return await this.readOne(result.id);
   }
 
   async update(
-    existing: FieldRegion,
+    existing: Pick<FieldRegion, 'id'>,
     changes: ChangesOf<FieldRegion, UpdateFieldRegion>,
   ) {
-    const { directorId, ...simpleChanges } = changes;
+    const { directorId, fieldZoneId, ...simpleChanges } = changes;
 
     if (directorId) {
       // TODO update director - lol this was never implemented
     }
 
+    if (fieldZoneId) {
+      // TODO update field zone - neither was this
+    }
+
     await this.updateProperties(existing, simpleChanges);
+
+    return await this.readOne(existing.id);
   }
 
   protected hydrate() {
@@ -74,13 +99,16 @@ export class FieldRegionRepository extends DtoRepository(FieldRegion) {
         ])
         .return<{ dto: UnsecuredDto<FieldRegion> }>(
           merge('props', {
-            director: 'director.id',
-            fieldZone: 'fieldZone.id',
+            director: 'director { .id }',
+            fieldZone: 'fieldZone { .id }',
           }).as('dto'),
         );
   }
 
   async list({ filter, ...input }: FieldRegionListInput, session: Session) {
+    if (!this.privileges.forUser(session).can('read')) {
+      return SecuredList.Redacted;
+    }
     const result = await this.db
       .query()
       .match(requestingUser(session))

src/components/field-region/field-region.resolver.ts

@@ -63,15 +63,17 @@ export class FieldRegionResolver {
     @Parent() fieldRegion: FieldRegion,
     @Loader(UserLoader) users: LoaderOf<UserLoader>,
   ): Promise<SecuredUser> {
-    return await mapSecuredValue(fieldRegion.director, (id) => users.load(id));
+    return await mapSecuredValue(fieldRegion.director, ({ id }) =>
+      users.load(id),
+    );
   }
 
   @ResolveField(() => SecuredFieldZone)
   async fieldZone(
     @Parent() fieldRegion: FieldRegion,
     @Loader(FieldZoneLoader) fieldZones: LoaderOf<FieldZoneLoader>,
   ): Promise<SecuredFieldZone> {
-    return await mapSecuredValue(fieldRegion.fieldZone, (id) =>
+    return await mapSecuredValue(fieldRegion.fieldZone, ({ id }) =>
       fieldZones.load(id),
     );
   }

src/components/field-region/field-region.service.ts

@@ -1,15 +1,12 @@
 import { Injectable } from '@nestjs/common';
 import {
-  DuplicateException,
   ID,
   ObjectView,
-  SecuredList,
   ServerException,
   Session,
   UnsecuredDto,
-} from '../../common';
-import { HandleIdLookup, ILogger, Logger } from '../../core';
-import { mapListResults } from '../../core/database/results';
+} from '~/common';
+import { HandleIdLookup, ILogger, Logger } from '~/core';
 import { Privileges } from '../authorization';
 import {
   CreateFieldRegion,
@@ -33,21 +30,8 @@ export class FieldRegionService {
     session: Session,
   ): Promise<FieldRegion> {
     this.privileges.for(session, FieldRegion).verifyCan('create');
-    if (!(await this.repo.isUnique(input.name))) {
-      throw new DuplicateException(
-        'fieldRegion.name',
-        'FieldRegion with this name already exists.',
-      );
-    }
-
-    const result = await this.repo.create(input, session);
-
-    if (!result) {
-      throw new ServerException('failed to create field region');
-    }
-
-    this.logger.debug(`field region created`, { id: result.id });
-    return await this.readOne(result.id, session);
+    const dto = await this.repo.create(input, session);
+    return this.secure(dto, session);
   }
 
   @HandleIdLookup(FieldRegion)
@@ -62,36 +46,31 @@ export class FieldRegionService {
     });
 
     const result = await this.repo.readOne(id);
-    return await this.secure(result, session);
+    return this.secure(result, session);
   }
 
   async readMany(ids: readonly ID[], session: Session) {
     const fieldRegions = await this.repo.readMany(ids);
-    return await Promise.all(
-      fieldRegions.map((dto) => this.secure(dto, session)),
-    );
+    return fieldRegions.map((dto) => this.secure(dto, session));
   }
 
-  private async secure(
-    dto: UnsecuredDto<FieldRegion>,
-    session: Session,
-  ): Promise<FieldRegion> {
+  private secure(dto: UnsecuredDto<FieldRegion>, session: Session) {
     return this.privileges.for(session, FieldRegion).secure(dto);
   }
 
   async update(
     input: UpdateFieldRegion,
     session: Session,
   ): Promise<FieldRegion> {
-    const fieldRegion = await this.readOne(input.id, session);
+    const fieldRegion = await this.repo.readOne(input.id);
+
     const changes = this.repo.getActualChanges(fieldRegion, input);
     this.privileges
       .for(session, FieldRegion, fieldRegion)
       .verifyChanges(changes);
 
-    await this.repo.update(fieldRegion, changes);
-
-    return await this.readOne(input.id, session);
+    const updated = await this.repo.update(fieldRegion, changes);
+    return this.secure(updated, session);
   }
 
   async delete(id: ID, session: Session): Promise<void> {
@@ -111,11 +90,10 @@ export class FieldRegionService {
     input: FieldRegionListInput,
     session: Session,
   ): Promise<FieldRegionListOutput> {
-    if (this.privileges.for(session, FieldRegion).can('read')) {
-      const results = await this.repo.list(input, session);
-      return await mapListResults(results, (dto) => this.secure(dto, session));
-    } else {
-      return SecuredList.Redacted;
-    }
+    const results = await this.repo.list(input, session);
+    return {
+      ...results,
+      items: results.items.map((dto) => this.secure(dto, session)),
+    };
   }
 }