feat: add routes to update and delete instrument records

Author: joshunrau

apps/api/src/instrument-records/dto/update-instrument-record.dto.ts

@@ -0,0 +1,6 @@
+import { DataTransferObject } from '@douglasneuroinformatics/libnest';
+import { z } from 'zod';
+
+export class UpdateInstrumentRecordDto extends DataTransferObject({
+  data: z.union([z.record(z.string(), z.any()), z.array(z.any())])
+}) {}

apps/api/src/instrument-records/instrument-records.controller.ts

@@ -1,13 +1,14 @@
 /* eslint-disable perfectionist/sort-classes */
 
-import { CurrentUser, ParseSchemaPipe, RouteAccess } from '@douglasneuroinformatics/libnest';
+import { CurrentUser, ParseSchemaPipe, RouteAccess, ValidObjectIdPipe } from '@douglasneuroinformatics/libnest';
 import type { AppAbility } from '@douglasneuroinformatics/libnest';
-import { Body, Controller, Get, Post, Query } from '@nestjs/common';
+import { Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, Patch, Post, Query } from '@nestjs/common';
 import { ApiOperation, ApiTags } from '@nestjs/swagger';
 import type { InstrumentKind } from '@opendatacapture/runtime-core';
 import { z } from 'zod';
 
 import { CreateInstrumentRecordDto } from './dto/create-instrument-record.dto';
+import { UpdateInstrumentRecordDto } from './dto/update-instrument-record.dto';
 import { UploadInstrumentRecordsDto } from './dto/upload-instrument-record.dto';
 import { InstrumentRecordsService } from './instrument-records.service';
 
@@ -51,6 +52,14 @@ export class InstrumentRecordsController {
     return this.instrumentRecordsService.find({ groupId, instrumentId, kind, minDate, subjectId }, { ability });
   }
 
+  @ApiOperation({ summary: 'Delete Record' })
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @RouteAccess({ action: 'delete', subject: 'InstrumentRecord' })
+  async deleteById(@Param('id', ValidObjectIdPipe) id: string, @CurrentUser('ability') ability: AppAbility) {
+    await this.instrumentRecordsService.deleteById(id, { ability });
+  }
+
   @ApiOperation({ summary: 'Export Records' })
   @Get('export')
   @RouteAccess({ action: 'read', subject: 'InstrumentRecord' })
@@ -68,4 +77,15 @@ export class InstrumentRecordsController {
   ): Promise<{ [key: string]: { intercept: number; slope: number; stdErr: number } }> {
     return this.instrumentRecordsService.linearModel({ groupId, instrumentId }, { ability });
   }
+
+  @ApiOperation({ summary: 'Update Instrument Record' })
+  @Patch(':id')
+  @RouteAccess({ action: 'delete', subject: 'InstrumentRecord' })
+  updateById(
+    @Param('id', ValidObjectIdPipe) id: string,
+    @Body() { data }: UpdateInstrumentRecordDto,
+    @CurrentUser('ability') ability: AppAbility
+  ) {
+    return this.instrumentRecordsService.updateById(id, data, { ability });
+  }
 }

apps/api/src/instrument-records/instrument-records.service.ts

@@ -2,8 +2,8 @@ import { replacer, reviver, yearsPassed } from '@douglasneuroinformatics/libjs';
 import { accessibleQuery, InjectModel } from '@douglasneuroinformatics/libnest';
 import type { Model } from '@douglasneuroinformatics/libnest';
 import { linearRegression } from '@douglasneuroinformatics/libstats';
-import { Injectable, UnprocessableEntityException } from '@nestjs/common';
-import type { ScalarInstrument } from '@opendatacapture/runtime-core';
+import { BadRequestException, Injectable, NotFoundException, UnprocessableEntityException } from '@nestjs/common';
+import type { Json, ScalarInstrument } from '@opendatacapture/runtime-core';
 import { DEFAULT_GROUP_NAME } from '@opendatacapture/schemas/core';
 import type {
   CreateInstrumentRecordData,
@@ -15,7 +15,7 @@ import type {
 } from '@opendatacapture/schemas/instrument-records';
 import { Prisma } from '@prisma/client';
 import type { Session } from '@prisma/client';
-import { isNumber, pickBy } from 'lodash-es';
+import { isNumber, mergeWith, pickBy } from 'lodash-es';
 
 import type { EntityOperationOptions } from '@/core/types';
 import { GroupsService } from '@/groups/groups.service';
@@ -105,6 +105,10 @@ export class InstrumentRecordsService {
   }
 
   async deleteById(id: string, { ability }: EntityOperationOptions = {}) {
+    const isExisting = await this.instrumentRecordModel.exists({ id });
+    if (!isExisting) {
+      throw new NotFoundException(`Could not find record with ID '${id}'`);
+    }
     return this.instrumentRecordModel.delete({
       where: { AND: [accessibleQuery(ability, 'delete', 'InstrumentRecord')], id }
     });
@@ -189,12 +193,7 @@ export class InstrumentRecordsService {
 
     const records = await this.instrumentRecordModel.findMany({
       include: {
-        instrument: {
-          select: {
-            bundle: true,
-            id: true
-          }
-        }
+        instrument: false
       },
       where: {
         AND: [
@@ -218,9 +217,7 @@ export class InstrumentRecordsService {
     if (groupId) {
       await this.groupsService.findById(groupId);
     }
-    const instrument = await this.instrumentsService
-      .findById(instrumentId)
-      .then((instrument) => this.instrumentsService.getInstrumentInstance(instrument));
+    const instrument = await this.getInstrumentById(instrumentId);
 
     if (instrument.kind === 'SERIES') {
       throw new UnprocessableEntityException(`Cannot create linear model for series instrument '${instrument.id}'`);
@@ -261,6 +258,47 @@ export class InstrumentRecordsService {
     return results;
   }
 
+  async updateById(id: string, data: unknown[] | { [key: string]: unknown }, { ability }: EntityOperationOptions = {}) {
+    const instrumentRecord = await this.instrumentRecordModel.findFirst({
+      where: { id }
+    });
+    if (!instrumentRecord) {
+      throw new NotFoundException(`Could not find record with ID '${id}'`);
+    }
+
+    if (Array.isArray(instrumentRecord.data) && !Array.isArray(data)) {
+      throw new BadRequestException('Data must be an array when the instrument record data is an array');
+    }
+
+    // all records must be attached to scalar instruments
+    const instrument = (await this.getInstrumentById(instrumentRecord.instrumentId)) as ScalarInstrument;
+
+    const updatedData = mergeWith(instrumentRecord.data, data, (updatedValue: unknown, sourceValue: unknown) => {
+      if (Array.isArray(sourceValue)) {
+        return updatedValue;
+      }
+      return undefined;
+    });
+
+    const parseResult = await instrument.validationSchema.safeParseAsync(updatedData);
+    if (!parseResult.success) {
+      throw new BadRequestException({
+        issues: parseResult.error.issues,
+        message: 'Merged data does not match validation schema'
+      });
+    }
+
+    return this.instrumentRecordModel.update({
+      data: {
+        computedMeasures: instrument.measures
+          ? this.instrumentMeasuresService.computeMeasures(instrument.measures, parseResult.data as Json)
+          : null,
+        data: parseResult.data
+      },
+      where: { AND: [accessibleQuery(ability, 'delete', 'InstrumentRecord')], id }
+    });
+  }
+
   async upload(
     { groupId, instrumentId, records }: UploadInstrumentRecordsData,
     options?: EntityOperationOptions
@@ -340,6 +378,12 @@ export class InstrumentRecordsService {
     }
   }
 
+  private getInstrumentById(instrumentId: string) {
+    return this.instrumentsService
+      .findById(instrumentId)
+      .then((instrument) => this.instrumentsService.getInstrumentInstance(instrument));
+  }
+
   private parseJson(data: unknown) {
     return JSON.parse(JSON.stringify(data), reviver) as unknown;
   }