Merge pull request #3166 from SeedCompany/0940-EdgeDB-User-Unavailability-Queries

Author: CarsonF

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.edgedb.repository.ts

@@ -0,0 +1,70 @@
+import { Injectable } from '@nestjs/common';
+import { Range } from 'edgedb';
+import { ID, PublicOf } from '~/common';
+import { e, RepoFor } from '~/core/edgedb';
+import {
+  CreateUnavailability,
+  Unavailability,
+  UpdateUnavailability,
+} from './dto';
+import { UnavailabilityRepository } from './unavailability.repository';
+
+@Injectable()
+export class UnavailabilityEdgeDBRepository
+  extends RepoFor(Unavailability, {
+    hydrate: (unavailability) => ({
+      ...unavailability['*'],
+      start: e.assert_exists(e.range_get_lower(unavailability.dates)),
+      end: e.assert_exists(e.range_get_upper(unavailability.dates)),
+    }),
+  }).customize((cls) => {
+    return class extends cls {
+      async create(input: CreateUnavailability) {
+        const user = e.cast(e.User, e.uuid(input.userId));
+        const inserted = e.insert(e.User.Unavailability, {
+          description: input.description,
+          dates: new Range(input.start, input.end),
+        });
+        const updatedUser = e.update(user, () => ({
+          set: {
+            unavailabilities: { '+=': inserted },
+          },
+        }));
+        const query = e.select(inserted, (u) => ({
+          ...this.hydrate(u),
+          updatedUser, // Attach to query, so it is executed.
+        }));
+        return await this.db.run(query);
+      }
+
+      async update(input: UpdateUnavailability) {
+        const unavailability = e.cast(e.User.Unavailability, e.uuid(input.id));
+        const updated = e.update(unavailability, () => ({
+          set: {
+            description: input.description,
+            dates: e.cast(
+              e.range(e.datetime),
+              e.range(
+                input.start ?? e.range_get_lower(unavailability.dates),
+                input.end ?? e.range_get_upper(unavailability.dates),
+              ),
+            ),
+          },
+        }));
+        const query = e.select(updated, this.hydrate);
+        return await this.db.run(query);
+      }
+    };
+  })
+  implements PublicOf<UnavailabilityRepository>
+{
+  async getUserIdByUnavailability(id: ID) {
+    const unavailability = e.cast(e.User.Unavailability, e.uuid(id));
+    const query = e.assert_exists(
+      e.select(e.User, (user) => ({
+        filter_single: e.op(unavailability, 'in', user.unavailabilities),
+      })),
+    );
+    return await this.db.run(query);
+  }
+}

src/components/user/unavailability/unavailability.module.ts

@@ -1,5 +1,7 @@
 import { forwardRef, Module } from '@nestjs/common';
+import { splitDb } from '~/core/database';
 import { AuthorizationModule } from '../../authorization/authorization.module';
+import { UnavailabilityEdgeDBRepository } from './unavailability.edgedb.repository';
 import { UnavailabilityLoader } from './unavailability.loader';
 import { UnavailabilityRepository } from './unavailability.repository';
 import { UnavailabilityResolver } from './unavailability.resolver';
@@ -10,7 +12,7 @@ import { UnavailabilityService } from './unavailability.service';
   providers: [
     UnavailabilityResolver,
     UnavailabilityService,
-    UnavailabilityRepository,
+    splitDb(UnavailabilityRepository, UnavailabilityEdgeDBRepository),
     UnavailabilityLoader,
   ],
   exports: [UnavailabilityService],

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)),
+    };
   }
 }