Isolate Neo4j specific code

Author: bryanjnelson

src/components/periodic-report/handlers/abstract-periodic-report-sync.ts

@@ -1,15 +1,17 @@
 import { type DateTimeUnit } from 'luxon';
 import { type CalendarDate, DateInterval, type ID, type Range } from '~/common';
 import { type ReportType } from '../dto';
-import { type PeriodicReportService } from '../periodic-report.service';
+import { type PeriodicReportRepository } from '../periodic-report.repository';
 
 export type Intervals = [
   updated: DateInterval | null,
   previous: DateInterval | null,
 ];
 
 export abstract class AbstractPeriodicReportSync {
-  constructor(protected readonly periodicReports: PeriodicReportService) {}
+  constructor(
+    protected readonly periodicReportsRepo: PeriodicReportRepository,
+  ) {}
 
   protected async sync(
     parent: ID,
@@ -20,9 +22,12 @@ export abstract class AbstractPeriodicReportSync {
     },
     finalAt?: CalendarDate,
   ) {
-    await this.periodicReports.delete(parent, type, diff.removals);
+    if (!diff) {
+      return;
+    }
+    await this.periodicReportsRepo.delete(parent, type, diff.removals);
 
-    await this.periodicReports.merge({
+    await this.periodicReportsRepo.merge({
       type,
       parent,
       intervals: diff.additions,
@@ -31,7 +36,7 @@ export abstract class AbstractPeriodicReportSync {
     if (!finalAt) {
       return;
     }
-    await this.periodicReports.mergeFinalReport(parent, type, finalAt);
+    await this.periodicReportsRepo.mergeFinalReport(parent, type, finalAt);
   }
 
   /**

src/components/periodic-report/handlers/sync-periodic-report-to-project.handler.ts

@@ -1,10 +1,16 @@
 import { type DateTimeUnit } from 'luxon';
 import { type DateInterval } from '~/common';
-import { EventsHandler, type IEventHandler, ILogger, Logger } from '~/core';
+import {
+  ConfigService,
+  EventsHandler,
+  type IEventHandler,
+  ILogger,
+  Logger,
+} from '~/core';
 import { projectRange } from '../../project/dto';
 import { ProjectUpdatedEvent } from '../../project/events';
 import { ReportPeriod, ReportType } from '../dto';
-import { PeriodicReportService } from '../periodic-report.service';
+import { PeriodicReportRepository } from '../periodic-report.repository';
 import {
   AbstractPeriodicReportSync,
   type Intervals,
@@ -18,13 +24,18 @@ export class SyncPeriodicReportsToProjectDateRange
   implements IEventHandler<SubscribedEvent>
 {
   constructor(
-    periodicReports: PeriodicReportService,
+    periodicReportsRepo: PeriodicReportRepository,
+    private readonly config: ConfigService,
     @Logger('periodic-reports:project-sync') private readonly logger: ILogger,
   ) {
-    super(periodicReports);
+    super(periodicReportsRepo);
   }
 
   async handle(event: SubscribedEvent) {
+    if (this.config.databaseEngine === 'gel') {
+      return;
+    }
+
     this.logger.debug('Project mutation, syncing periodic reports', {
       ...event,
       event: event.constructor.name,

src/components/periodic-report/handlers/sync-progress-report-to-engagement.handler.ts

@@ -1,6 +1,12 @@
 import { Settings } from 'luxon';
 import { DateInterval, type UnsecuredDto } from '~/common';
-import { EventsHandler, type IEventHandler, ILogger, Logger } from '~/core';
+import {
+  ConfigService,
+  EventsHandler,
+  type IEventHandler,
+  ILogger,
+  Logger,
+} from '~/core';
 import { EngagementService } from '../../engagement';
 import { type Engagement, engagementRange } from '../../engagement/dto';
 import {
@@ -9,7 +15,7 @@ import {
 } from '../../engagement/events';
 import { ProjectUpdatedEvent } from '../../project/events';
 import { ReportType } from '../dto';
-import { PeriodicReportService } from '../periodic-report.service';
+import { PeriodicReportRepository } from '../periodic-report.repository';
 import {
   AbstractPeriodicReportSync,
   type Intervals,
@@ -30,14 +36,19 @@ export class SyncProgressReportToEngagementDateRange
   implements IEventHandler<SubscribedEvent>
 {
   constructor(
-    periodicReports: PeriodicReportService,
+    periodicReportsRepo: PeriodicReportRepository,
+    private readonly config: ConfigService,
     private readonly engagements: EngagementService,
     @Logger('progress-report:engagement-sync') private readonly logger: ILogger,
   ) {
-    super(periodicReports);
+    super(periodicReportsRepo);
   }
 
   async handle(event: SubscribedEvent) {
+    if (this.config.databaseEngine === 'gel') {
+      return;
+    }
+
     // Only LanguageEngagements
     if (
       !(

src/components/periodic-report/periodic-report.repository.ts

@@ -12,6 +12,7 @@ import {
 import {
   type CalendarDate,
   CreationFailed,
+  DateInterval,
   generateId,
   type ID,
   NotFoundException,
@@ -34,6 +35,7 @@ import {
   variable,
   type Variable,
 } from '~/core/database/query';
+import { ILogger, Logger } from '../../core';
 import { File } from '../file/dto';
 import {
   ProgressReport,
@@ -61,11 +63,16 @@ export class PeriodicReportRepository extends DtoRepository<
 >(IPeriodicReport) {
   constructor(
     private readonly progressRepo: ProgressReportExtraForPeriodicInterfaceRepository,
+    @Logger('periodic:report:service') private readonly logger: ILogger,
   ) {
     super();
   }
 
   async merge(input: MergePeriodicReports) {
+    if (input.intervals.length === 0) {
+      return;
+    }
+
     try {
       const Report = resolveReportType(input);
 
@@ -172,13 +179,44 @@ export class PeriodicReportRepository extends DtoRepository<
           'report.id as id, interval',
         );
 
-      return await query.run();
+      const result = await query.run();
+
+      this.logger.info(`Merged ${input.type.toLowerCase()} reports`, {
+        existing: input.intervals.length - result.length,
+        new: result.length,
+        parent: input.parent,
+        newIntervals: result.map(({ interval }) =>
+          DateInterval.fromObject(interval).toISO(),
+        ),
+      });
     } catch (exception) {
       const Report = resolveReportType({ type: input.type });
       throw new CreationFailed(Report, exception);
     }
   }
 
+  async mergeFinalReport(
+    parentId: ID,
+    type: ReportType,
+    at: CalendarDate,
+  ): Promise<void> {
+    const report = await this.getFinalReport(parentId, type);
+
+    if (report) {
+      if (+report.start === +at) {
+        // no change
+        return;
+      }
+      await this.update({ id: report.id, start: at, end: at });
+    } else {
+      await this.merge({
+        intervals: [{ start: at, end: at }],
+        type,
+        parent: parentId,
+      });
+    }
+  }
+
   async update(
     changes: Omit<UpdatePeriodicReportInput, 'reportFile'> &
       Pick<PeriodicReport, 'start' | 'end'>,
@@ -334,7 +372,12 @@ export class PeriodicReportRepository extends DtoRepository<
     type: ReportType,
     intervals: ReadonlyArray<Range<CalendarDate | null>>,
   ) {
-    return await this.db
+    intervals = intervals.filter((i) => i.start || i.end);
+    if (intervals.length === 0) {
+      return;
+    }
+
+    const result = await this.db
       .query()
       .unwind(
         intervals.map((i) => ({ start: i.start, end: i.end })),
@@ -386,6 +429,8 @@ export class PeriodicReportRepository extends DtoRepository<
       )
       .return<{ count: number }>('count(report) as count')
       .first();
+
+    this.logger.info('Deleted reports', { baseNodeId, type, ...result });
   }
 
   protected hydrate() {

src/components/periodic-report/periodic-report.service.ts

@@ -1,10 +1,9 @@
 import { Injectable } from '@nestjs/common';
 import {
   type CalendarDate,
-  DateInterval,
   type ID,
+  NotFoundException,
   type ObjectView,
-  type Range,
   type UnsecuredDto,
 } from '~/common';
 import { HandleIdLookup, IEventBus, ILogger, Logger } from '~/core';
@@ -15,7 +14,6 @@ import { FileService } from '../file';
 import { ProgressReport } from '../progress-report/dto';
 import {
   FinancialReport,
-  type MergePeriodicReports,
   NarrativeReport,
   type PeriodicReport,
   type PeriodicReportListInput,
@@ -39,21 +37,6 @@ export class PeriodicReportService {
     private readonly repo: PeriodicReportRepository,
   ) {}
 
-  async merge(input: MergePeriodicReports) {
-    if (input.intervals.length === 0) {
-      return;
-    }
-    const result = await this.repo.merge(input);
-    this.logger.info(`Merged ${input.type.toLowerCase()} reports`, {
-      existing: input.intervals.length - result.length,
-      new: result.length,
-      parent: input.parent,
-      newIntervals: result.map(({ interval }) =>
-        DateInterval.fromObject(interval).toISO(),
-      ),
-    });
-  }
-
   async update(input: UpdatePeriodicReportInput) {
     const currentRaw = await this.repo.readOne(input.id);
     const current = this.secure(currentRaw);
@@ -65,21 +48,17 @@ export class PeriodicReportService {
     const { reportFile, ...simpleChanges } = changes;
 
     const updated = this.secure(
-      await this.repo.update(
-        {
-          id: current.id,
-          start: current.start,
-          end: current.end,
-          ...simpleChanges,
-        },
-        session,
-      ),
-      session,
+      await this.repo.update({
+        id: current.id,
+        start: current.start,
+        end: current.end,
+        ...simpleChanges,
+      }),
     );
 
     if (reportFile) {
       const file = await this.files.updateDefinedFile(
-        this.secure(current, session).reportFile,
+        this.secure(currentRaw).reportFile,
         'file',
         reportFile,
       );
@@ -168,47 +147,11 @@ export class PeriodicReportService {
       : undefined;
   }
 
-  async delete(
-    parent: ID,
-    type: ReportType,
-    intervals: ReadonlyArray<Range<CalendarDate | null>>,
-  ) {
-    intervals = intervals.filter((i) => i.start || i.end);
-    if (intervals.length === 0) {
-      return;
-    }
-    const result = await this.repo.delete(parent, type, intervals);
-
-    this.logger.info('Deleted reports', { parent, type, ...result });
-  }
-
   async getFinalReport(
     parentId: ID,
     type: ReportType,
   ): Promise<PeriodicReport | undefined> {
     const report = await this.repo.getFinalReport(parentId, type);
     return report ? this.secure(report) : undefined;
   }
-
-  async mergeFinalReport(
-    parentId: ID,
-    type: ReportType,
-    at: CalendarDate,
-  ): Promise<void> {
-    const report = await this.repo.getFinalReport(parentId, type);
-
-    if (report) {
-      if (+report.start === +at) {
-        // no change
-        return;
-      }
-      await this.repo.update({ id: report.id, start: at, end: at }, session);
-    } else {
-      await this.merge({
-        intervals: [{ start: at, end: at }],
-        type,
-        parent: parentId,
-      });
-    }
-  }
 }