Refactor unavailability service and repo per edgedb migration requirements

Author: Andre Turner

src/components/user/unavailability/dto/unavailability.dto.ts

@@ -1,13 +1,13 @@
 import { Field, ObjectType } from '@nestjs/graphql';
 import { keys as keysOf } from 'ts-transformer-keys';
-import { e } from '~/core/edgedb';
-import { RegisterResource } from '~/core/resources';
 import {
   Resource,
   SecuredDateTime,
   SecuredProps,
   SecuredString,
-} from '../../../../common';
+} from '~/common';
+import { e } from '~/core/edgedb';
+import { RegisterResource } from '~/core/resources';
 
 @RegisterResource({ db: e.User.Unavailability })
 @ObjectType({

src/components/user/unavailability/unavailability.repository.ts

@@ -1,15 +1,14 @@
 import { Injectable } from '@nestjs/common';
 import { node, relation } from 'cypher-query-builder';
-import { ChangesOf } from '~/core/database/changes';
-import { ID, ServerException } from '../../../common';
-import { DtoRepository } from '../../../core';
+import { ID, NotFoundException, ServerException } from '~/common';
+import { DtoRepository } from '~/core';
 import {
   ACTIVE,
   createNode,
   createRelationships,
   paginate,
   sorting,
-} from '../../../core/database/query';
+} from '~/core/database/query';
 import {
   CreateUnavailability,
   Unavailability,
@@ -38,18 +37,17 @@ export class UnavailabilityRepository extends DtoRepository(Unavailability) {
     if (!result) {
       throw new ServerException('Could not create unavailability');
     }
-    return result.id;
+    return await this.readOne(result.id);
   }
 
-  async update(
-    existing: Unavailability,
-    changes: ChangesOf<Unavailability, UpdateUnavailability>,
-  ) {
-    return await this.updateProperties(existing, changes);
+  async update(changes: UpdateUnavailability) {
+    const { id, ...simpleChanges } = changes;
+    await this.updateProperties({ id }, simpleChanges);
+    return await this.readOne(id);
   }
 
   async getUserIdByUnavailability(id: ID) {
-    return await this.db
+    const result = await this.db
       .query()
       .match([
         node('user', 'User'),
@@ -58,6 +56,14 @@ export class UnavailabilityRepository extends DtoRepository(Unavailability) {
       ])
       .return<{ id: ID }>('user.id as id')
       .first();
+
+    if (!result) {
+      throw new NotFoundException(
+        'Could not find user associated with unavailability',
+        'user.unavailability',
+      );
+    }
+    return result;
   }
 
   async list(input: UnavailabilityListInput) {

src/components/user/unavailability/unavailability.service.ts

@@ -1,14 +1,6 @@
 import { Injectable } from '@nestjs/common';
-import {
-  ID,
-  NotFoundException,
-  ObjectView,
-  ServerException,
-  Session,
-  UnsecuredDto,
-} from '../../../common';
-import { HandleIdLookup, ILogger, Logger } from '../../../core';
-import { mapListResults } from '../../../core/database/results';
+import { ID, ObjectView, Session, UnsecuredDto } from '~/common';
+import { HandleIdLookup } from '~/core';
 import { Privileges } from '../../authorization';
 import {
   CreateUnavailability,
@@ -22,7 +14,6 @@ import { UnavailabilityRepository } from './unavailability.repository';
 @Injectable()
 export class UnavailabilityService {
   constructor(
-    @Logger('unavailability:service') private readonly logger: ILogger,
     private readonly privileges: Privileges,
     private readonly repo: UnavailabilityRepository,
   ) {}
@@ -31,24 +22,9 @@ export class UnavailabilityService {
     input: CreateUnavailability,
     session: Session,
   ): Promise<Unavailability> {
-    try {
-      this.privileges.for(session, Unavailability).verifyCan('create');
-
-      // create and connect the Unavailability to the User.
-      const id = await this.repo.create(input);
-
-      this.logger.debug(`Created user unavailability`, {
-        id,
-        userId: input.userId,
-      });
-
-      return await this.readOne(id, session);
-    } catch {
-      this.logger.error(`Could not create unavailability`, {
-        userId: input.userId,
-      });
-      throw new ServerException('Could not create unavailability');
-    }
+    this.privileges.for(session, Unavailability).verifyCan('create');
+    const result = await this.repo.create(input);
+    return this.secure(result, session);
   }
 
   @HandleIdLookup(Unavailability)
@@ -58,57 +34,37 @@ export class UnavailabilityService {
     _view?: ObjectView,
   ): Promise<Unavailability> {
     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 unavailabilities = await this.repo.readMany(ids);
-    return await Promise.all(
-      unavailabilities.map((dto) => this.secure(dto, session)),
-    );
+    return unavailabilities.map((dto) => this.secure(dto, session));
   }
 
-  private async secure(
-    dto: UnsecuredDto<Unavailability>,
-    session: Session,
-  ): Promise<Unavailability> {
+  private secure(dto: UnsecuredDto<Unavailability>, session: Session) {
     return this.privileges.for(session, Unavailability).secure(dto);
   }
 
   async update(
     input: UpdateUnavailability,
     session: Session,
   ): Promise<Unavailability> {
-    const unavailability = await this.readOne(input.id, session);
-
+    const unavailability = await this.repo.readOne(input.id);
     const result = await this.repo.getUserIdByUnavailability(input.id);
-    if (!result) {
-      throw new NotFoundException(
-        'Could not find user associated with unavailability',
-        'user.unavailability',
-      );
-    }
-
     const changes = this.repo.getActualChanges(unavailability, input);
-
     // TODO move this condition into policies
     if (result.id !== session.userId) {
       this.privileges
         .for(session, Unavailability, unavailability)
         .verifyChanges(changes);
     }
-    return await this.repo.update(unavailability, changes);
+    const updated = await this.repo.update({ id: input.id, ...changes });
+    return this.secure(updated, session);
   }
 
-  async delete(id: ID, session: Session): Promise<void> {
-    this.logger.debug(`mutation delete unavailability`);
-    const ua = await this.readOne(id, session);
-    if (!ua) {
-      throw new NotFoundException(
-        'Unavailability not found',
-        'unavailability.id',
-      );
-    }
+  async delete(id: ID, _session: Session): Promise<void> {
+    const ua = await this.repo.readOne(id);
     await this.repo.deleteNode(ua);
   }
 
@@ -117,6 +73,9 @@ export class UnavailabilityService {
     session: Session,
   ): Promise<UnavailabilityListOutput> {
     const results = await this.repo.list(input);
-    return await mapListResults(results, (dto) => this.secure(dto, session));
+    return {
+      ...results,
+      items: results.items.map((dto) => this.secure(dto, session)),
+    };
   }
 }