Refactor FieldZone service to move neo4j needs into neo4j repo

Author: CarsonF

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

@@ -2,7 +2,14 @@ import { Injectable } from '@nestjs/common';
 import { node, Query, relation } from 'cypher-query-builder';
 import { DateTime } from 'luxon';
 import { ChangesOf } from '~/core/database/changes';
-import { ID, Session, UnsecuredDto } from '../../common';
+import {
+  DuplicateException,
+  ID,
+  SecuredList,
+  ServerException,
+  Session,
+  UnsecuredDto,
+} from '../../common';
 import { DtoRepository } from '../../core';
 import {
   ACTIVE,
@@ -25,6 +32,13 @@ import {
 @Injectable()
 export class FieldZoneRepository extends DtoRepository(FieldZone) {
   async create(input: CreateFieldZone, session: Session) {
+    if (!(await this.isUnique(input.name))) {
+      throw new DuplicateException(
+        'fieldZone.name',
+        'FieldZone with this name already exists.',
+      );
+    }
+
     const initialProps = {
       name: input.name,
       canDelete: true,
@@ -42,7 +56,12 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
       )
       .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 zone');
+    }
+
+    return await this.readOne(result.id);
   }
 
   protected hydrate() {
@@ -62,7 +81,7 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
   }
 
   async update(
-    existing: FieldZone,
+    existing: Pick<FieldZone, 'id'>,
     changes: ChangesOf<FieldZone, UpdateFieldZone>,
   ) {
     const { directorId, ...simpleChanges } = changes;
@@ -72,6 +91,8 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
     }
 
     await this.updateProperties(existing, simpleChanges);
+
+    return await this.readOne(existing.id);
   }
 
   private async updateDirector(directorId: ID, id: ID) {
@@ -103,6 +124,9 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
   }
 
   async list({ filter, ...input }: FieldZoneListInput, session: Session) {
+    if (!this.privileges.forUser(session).can('read')) {
+      return SecuredList.Redacted;
+    }
     const result = await this.db
       .query()
       .match(requestingUser(session))

src/components/field-zone/field-zone.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';
 import { Privileges } from '../authorization';
 import {
   CreateFieldZone,
@@ -30,20 +27,8 @@ export class FieldZoneService {
 
   async create(input: CreateFieldZone, session: Session): Promise<FieldZone> {
     this.privileges.for(session, FieldZone).verifyCan('create');
-    if (!(await this.repo.isUnique(input.name))) {
-      throw new DuplicateException(
-        'fieldZone.name',
-        'FieldZone with this name already exists.',
-      );
-    }
-    const result = await this.repo.create(input, session);
-
-    if (!result) {
-      throw new ServerException('failed to create field zone');
-    }
-
-    this.logger.debug(`field zone 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(FieldZone)
@@ -58,32 +43,26 @@ export class FieldZoneService {
     });
 
     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 fieldZones = await this.repo.readMany(ids);
-    return await Promise.all(
-      fieldZones.map((dto) => this.secure(dto, session)),
-    );
+    return fieldZones.map((dto) => this.secure(dto, session));
   }
 
-  private async secure(
-    dto: UnsecuredDto<FieldZone>,
-    session: Session,
-  ): Promise<FieldZone> {
+  private secure(dto: UnsecuredDto<FieldZone>, session: Session) {
     return this.privileges.for(session, FieldZone).secure(dto);
   }
 
   async update(input: UpdateFieldZone, session: Session): Promise<FieldZone> {
-    const fieldZone = await this.readOne(input.id, session);
+    const fieldZone = await this.repo.readOne(input.id);
 
     const changes = this.repo.getActualChanges(fieldZone, input);
     this.privileges.for(session, FieldZone, fieldZone).verifyChanges(changes);
 
-    await this.repo.update(fieldZone, changes);
-
-    return await this.readOne(input.id, session);
+    const updated = await this.repo.update(fieldZone, changes);
+    return this.secure(updated, session);
   }
 
   async delete(id: ID, session: Session): Promise<void> {
@@ -103,11 +82,10 @@ export class FieldZoneService {
     input: FieldZoneListInput,
     session: Session,
   ): Promise<FieldZoneListOutput> {
-    if (this.privileges.for(session, FieldZone).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)),
+    };
   }
 }