[EdgeDB] - Ceremony queries (#3183)

Co-authored-by: Brent Kulwicki <[email protected]>

Author: brentkulwicki

src/components/ceremony/ceremony.edgedb.repository.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { NotImplementedException, PublicOf } from '~/common';
+import { castToEnum, RepoFor } from '~/core/edgedb';
+import { CeremonyRepository } from './ceremony.repository';
+import { Ceremony, CeremonyType } from './dto';
+
+@Injectable()
+export class CeremonyEdgeDBRepository
+  extends RepoFor(Ceremony, {
+    hydrate: (ceremony) => ({
+      ...ceremony['*'],
+      engagement: true,
+      type: castToEnum(ceremony.__type__.name.slice(12, -8), CeremonyType),
+    }),
+  }).customize((cls, { defaults }) => {
+    return class extends cls {
+      static omit = [defaults.create];
+    };
+  })
+  implements PublicOf<CeremonyRepository>
+{
+  async create(): Promise<never> {
+    throw new NotImplementedException();
+  }
+}

src/components/ceremony/ceremony.module.ts

@@ -1,5 +1,7 @@
 import { forwardRef, Module } from '@nestjs/common';
+import { splitDb } from '~/core';
 import { AuthorizationModule } from '../authorization/authorization.module';
+import { CeremonyEdgeDBRepository } from './ceremony.edgedb.repository';
 import { CeremonyLoader } from './ceremony.loader';
 import { CeremonyRepository } from './ceremony.repository';
 import { CeremonyResolver } from './ceremony.resolver';
@@ -11,7 +13,7 @@ import * as handlers from './handlers';
   providers: [
     CeremonyResolver,
     CeremonyService,
-    CeremonyRepository,
+    splitDb(CeremonyRepository, CeremonyEdgeDBRepository),
     CeremonyLoader,
     ...Object.values(handlers),
   ],

src/components/ceremony/ceremony.repository.ts

@@ -1,8 +1,7 @@
 import { Injectable } from '@nestjs/common';
 import { node, Query, relation } from 'cypher-query-builder';
-import { ChangesOf } from '~/core/database/changes';
-import { ID, Session, UnsecuredDto } from '../../common';
-import { DtoRepository } from '../../core';
+import { ID, ServerException, Session, UnsecuredDto } from '~/common';
+import { DtoRepository } from '~/core';
 import {
   ACTIVE,
   createNode,
@@ -11,7 +10,7 @@ import {
   paginate,
   requestingUser,
   sorting,
-} from '../../core/database/query';
+} from '~/core/database/query';
 import {
   Ceremony,
   CeremonyListInput,
@@ -32,18 +31,22 @@ export class CeremonyRepository extends DtoRepository<
       actualDate: input.actualDate,
       canDelete: true,
     };
-    return await this.db
+    const result = await this.db
       .query()
       .apply(await createNode(Ceremony, { initialProps }))
       .return<{ id: ID }>('node.id as id')
       .first();
+
+    if (!result) {
+      throw new ServerException('failed to create a ceremony');
+    }
+    return result;
   }
 
-  async update(
-    existing: Ceremony,
-    changes: ChangesOf<Ceremony, UpdateCeremony>,
-  ) {
-    return await this.updateProperties(existing, changes);
+  async update(changes: UpdateCeremony, session: Session) {
+    const { id, ...simpleChanges } = changes;
+    await this.updateProperties({ id }, simpleChanges);
+    return await this.readOne(id, session);
   }
 
   protected hydrate(session: Session) {

src/components/ceremony/ceremony.resolver.ts

@@ -6,7 +6,7 @@ import {
   ListArg,
   LoggedInSession,
   Session,
-} from '../../common';
+} from '~/common';
 import { Loader, LoaderOf } from '../../core';
 import { CeremonyLoader, CeremonyService } from '../ceremony';
 import {

src/components/ceremony/ceremony.service.ts

@@ -8,7 +8,6 @@ import {
   UnsecuredDto,
 } from '../../common';
 import { HandleIdLookup, ILogger, Logger } from '../../core';
-import { mapListResults } from '../../core/database/results';
 import { Privileges } from '../authorization';
 import { CeremonyRepository } from './ceremony.repository';
 import {
@@ -23,26 +22,14 @@ import {
 export class CeremonyService {
   constructor(
     private readonly privileges: Privileges,
-    private readonly ceremonyRepo: CeremonyRepository,
+    private readonly repo: CeremonyRepository,
     @Logger('ceremony:service') private readonly logger: ILogger,
   ) {}
 
   async create(input: CreateCeremony): Promise<ID> {
-    try {
-      const result = await this.ceremonyRepo.create(input);
-
-      if (!result) {
-        throw new ServerException('failed to create a ceremony');
-      }
+    const { id } = await this.repo.create(input);
 
-      return result.id;
-    } catch (exception) {
-      this.logger.warning('Failed to create ceremony', {
-        exception,
-      });
-
-      throw exception;
-    }
+    return id;
   }
 
   @HandleIdLookup(Ceremony)
@@ -56,36 +43,41 @@ export class CeremonyService {
       throw new InputException('No ceremony id to search for', 'ceremony.id');
     }
 
-    const dto = await this.ceremonyRepo.readOne(id, session);
-    return await this.secure(dto, session);
+    const dto = await this.repo.readOne(id, session);
+    return this.secure(dto, session);
   }
 
   async readMany(ids: readonly ID[], session: Session) {
-    const ceremonies = await this.ceremonyRepo.readMany(ids, session);
-    return await Promise.all(
-      ceremonies.map((dto) => this.secure(dto, session)),
-    );
+    const ceremonies = await this.repo.readMany(ids, session);
+    return ceremonies.map((dto) => this.secure(dto, session));
   }
 
-  async secure(dto: UnsecuredDto<Ceremony>, session: Session) {
+  secure(dto: UnsecuredDto<Ceremony>, session: Session) {
     return this.privileges.for(session, Ceremony).secure(dto);
   }
 
   async update(input: UpdateCeremony, session: Session): Promise<Ceremony> {
-    const object = await this.readOne(input.id, session);
-    const changes = this.ceremonyRepo.getActualChanges(object, input);
+    const object = await this.repo.readOne(input.id, session);
+    const changes = this.repo.getActualChanges(object, input);
     this.privileges.for(session, Ceremony, object).verifyChanges(changes);
-    return await this.ceremonyRepo.update(object, changes);
+    const updated = await this.repo.update(
+      {
+        id: input.id,
+        ...changes,
+      },
+      session,
+    );
+    return this.secure(updated, session);
   }
 
   async delete(id: ID, session: Session): Promise<void> {
-    const object = await this.readOne(id, session);
+    const object = await this.repo.readOne(id, session);
 
     // Only called internally, not exposed directly to users
     // this.privileges.for(session, Ceremony, object).verifyCan('delete');
 
     try {
-      await this.ceremonyRepo.deleteNode(object);
+      await this.repo.deleteNode(object);
     } catch (exception) {
       this.logger.warning('Failed to delete Ceremony', {
         exception,
@@ -98,7 +90,10 @@ export class CeremonyService {
     input: CeremonyListInput,
     session: Session,
   ): Promise<CeremonyListOutput> {
-    const results = await this.ceremonyRepo.list(input, session);
-    return await mapListResults(results, (dto) => this.secure(dto, session));
+    const results = await this.repo.list(input, session);
+    return {
+      ...results,
+      items: results.items.map((dto) => this.secure(dto, session)),
+    };
   }
 }

src/components/ceremony/dto/ceremony.dto.ts

@@ -1,17 +1,17 @@
 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 {
   Calculated,
   Resource,
   SecuredBoolean,
-  SecuredDate,
+  SecuredDateNullable,
   SecuredProperty,
   SecuredProps,
   Sensitivity,
   SensitivityField,
-} from '../../../common';
+} from '~/common';
+import { e } from '~/core/edgedb';
+import { RegisterResource } from '~/core/resources';
 import { CeremonyType } from './ceremony-type.enum';
 
 @RegisterResource({ db: e.Engagement.Ceremony })
@@ -33,10 +33,10 @@ export class Ceremony extends Resource {
   readonly planned: SecuredBoolean;
 
   @Field()
-  readonly estimatedDate: SecuredDate;
+  readonly estimatedDate: SecuredDateNullable;
 
   @Field()
-  readonly actualDate: SecuredDate;
+  readonly actualDate: SecuredDateNullable;
 
   @SensitivityField({
     description: "Based on the project's sensitivity",

src/components/ceremony/dto/create-ceremony.dto.ts

@@ -1,5 +1,5 @@
 import { Field, InputType } from '@nestjs/graphql';
-import { CalendarDate, DateField } from '../../../common';
+import { CalendarDate, DateField } from '~/common';
 import { CeremonyType } from './ceremony-type.enum';
 
 @InputType()

src/components/ceremony/dto/update-ceremony.dto.ts

@@ -1,7 +1,7 @@
 import { Field, InputType, ObjectType } from '@nestjs/graphql';
 import { Type } from 'class-transformer';
 import { ValidateNested } from 'class-validator';
-import { CalendarDate, DateField, ID, IdField } from '../../../common';
+import { CalendarDate, DateField, ID, IdField } from '~/common';
 import { Ceremony } from './ceremony.dto';
 
 @InputType()

src/components/ceremony/handlers/create-engagement-default-ceremony.handler.ts

@@ -1,6 +1,11 @@
 import { node, relation } from 'cypher-query-builder';
 import { DateTime } from 'luxon';
-import { DatabaseService, EventsHandler, IEventHandler } from '../../../core';
+import {
+  ConfigService,
+  DatabaseService,
+  EventsHandler,
+  IEventHandler,
+} from '~/core';
 import { EngagementCreatedEvent } from '../../engagement/events';
 import { CeremonyService } from '../ceremony.service';
 import { CeremonyType } from '../dto';
@@ -11,6 +16,7 @@ export class CreateEngagementDefaultCeremonyHandler
 {
   constructor(
     private readonly ceremonies: CeremonyService,
+    private readonly config: ConfigService,
     private readonly db: DatabaseService,
   ) {}
 
@@ -22,6 +28,9 @@ export class CreateEngagementDefaultCeremonyHandler
           ? CeremonyType.Dedication
           : CeremonyType.Certification,
     };
+    if (this.config.databaseEngine === 'edgedb') {
+      return;
+    }
     const ceremonyId = await this.ceremonies.create(input);
 
     // connect ceremonyId to engagement