feat: Services CRUD

src/services/create.pipe.ts

@@ -0,0 +1,17 @@
+import { Injectable, PipeTransform } from '@nestjs/common';
+import { DampLabServicePipe } from '../services/damplab-services.pipe';
+import { CreateService } from './dtos/create.dto';
+
+@Injectable()
+export class CreateServicePipe implements PipeTransform<CreateService, Promise<CreateService>> {
+  constructor(private readonly damplabServicePipe: DampLabServicePipe) {}
+
+  async transform(value: CreateService): Promise<CreateService> {
+    // Ensure the services are valid
+    for (const service of value.allowedConnections) {
+      await this.damplabServicePipe.transform(service);
+    }
+
+    return value;
+  }
+}

src/services/damplab-services.module.ts

@@ -1,5 +1,6 @@
 import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
+import { CreateServicePipe } from './create.pipe';
 import { DampLabServicePipe } from './damplab-services.pipe';
 import { DampLabServicesResolver } from './damplab-services.resolver';
 import { DampLabServices } from './damplab-services.services';
@@ -8,7 +9,7 @@ import { ServiceUpdatePipe } from './update.pipe';
 
 @Module({
   imports: [MongooseModule.forFeature([{ name: DampLabService.name, schema: DampLabServiceSchema }])],
-  providers: [DampLabServicesResolver, DampLabServices, DampLabServicePipe, ServiceUpdatePipe],
+  providers: [DampLabServicesResolver, DampLabServices, DampLabServicePipe, ServiceUpdatePipe, CreateServicePipe],
   exports: [DampLabServices, DampLabServicePipe]
 })
 export class DampLabServicesModule {}

src/services/damplab-services.resolver.ts

@@ -1,27 +1,40 @@
 import { Resolver, Query, ResolveField, Parent, ID, Args, Mutation } from '@nestjs/graphql';
+import { CreateServicePipe } from './create.pipe';
 import { DampLabServicePipe } from './damplab-services.pipe';
 import { DampLabServices } from './damplab-services.services';
+import { CreateService } from './dtos/create.dto';
 import { ServiceChange } from './dtos/update.dto';
 import { DampLabService } from './models/damplab-service.model';
 import { ServiceUpdatePipe } from './update.pipe';
 
 @Resolver(() => DampLabService)
 export class DampLabServicesResolver {
   constructor(private readonly dampLabServices: DampLabServices) {}
 
   @Query(() => [DampLabService])
   async services(): Promise<DampLabService[]> {
     return this.dampLabServices.findAll();
   }
 
   @Mutation(() => DampLabService)
   async updateService(
     @Args('service', { type: () => ID }, DampLabServicePipe) service: DampLabService,
     @Args('changes', { type: () => ServiceChange }, ServiceUpdatePipe) changes: ServiceChange
   ): Promise<DampLabService> {
     return this.dampLabServices.update(service, changes);
   }
 
+  @Mutation(() => Boolean)
+  async deleteService(@Args('service', { type: () => ID }, DampLabServicePipe) service: DampLabService): Promise<boolean> {
+    await this.dampLabServices.delete(service);
+    return true;
+  }
+
+  @Mutation(() => DampLabService)
+  async createService(@Args('service', CreateServicePipe) service: CreateService): Promise<DampLabService> {
+    return this.dampLabServices.create(service);
+  }
+
   /**
    * Resolver which the `allowedConnections` field of the `DampLabService`
    * type. Allows for the recursive search on possible connections.

src/services/damplab-services.services.ts

@@ -4,28 +4,45 @@
 import { Model } from 'mongoose';
 import mongoose from 'mongoose';
 import { ServiceChange } from './dtos/update.dto';
+import { CreateService } from './dtos/create.dto';
 
 @Injectable()
 export class DampLabServices {
   constructor(@InjectModel(DampLabService.name) private readonly dampLabServiceModel: Model<DampLabServiceDocument>) {}
 
   findAll(): Promise<DampLabService[]> {
     return this.dampLabServiceModel.find().exec();
   }
 
   /**
    * Find a list of services by their IDs.
    */
   async findByIds(ids: mongoose.Types.ObjectId[]): Promise<DampLabService[]> {
     return this.dampLabServiceModel.find({ _id: { $in: ids } }).exec();
   }
 
   async findOne(id: string): Promise<DampLabService | null> {
     return this.dampLabServiceModel.findById(id).exec();
   }
 
   async update(service: DampLabService, changes: ServiceChange): Promise<DampLabService> {
     await this.dampLabServiceModel.updateOne({ _id: service._id }, changes);
     return (await this.dampLabServiceModel.findById(service._id))!;
   }
+
+  async delete(service: DampLabService): Promise<void> {
+    // Remove all allowed connections first
+    await this.dampLabServiceModel.updateMany(
+      {},
+      {
+        $pull: { allowedConnections: service._id }
+      }
+    );
+
+    await this.dampLabServiceModel.deleteOne({ _id: service._id });
+  }
+
+  async create(service: CreateService): Promise<DampLabService> {
+    return this.dampLabServiceModel.create(service);
+  }
 }

src/services/dtos/create.dto.ts

@@ -0,0 +1,8 @@
+import { ID, InputType, Field, OmitType } from '@nestjs/graphql';
+import { DampLabService } from '../models/damplab-service.model';
+
+@InputType()
+export class CreateService extends OmitType(DampLabService, ['_id', 'allowedConnections'] as const, InputType) {
+  @Field(() => [ID])
+  allowedConnections: string[];
+}