Merge branch 'main' into mpi-auth

scripts/src/commands/load/all.ts

@@ -92,7 +92,6 @@ export default class LoadDatabase extends Command {
   async insertServices(services: any[]): Promise<Map<string, ObjectId>> {
     /** Maps the ID as defined in the JSON file to the ID in the database */
     const serviceMap = new Map<string, ObjectId>();
-
     // For each of the services, save the info not including
     // the allowed connections
     for (const service of services) {

scripts/src/commands/reset/index.ts

@@ -17,6 +17,7 @@ export default class Reset extends Command {
     const { flags } = await this.parse(Reset);
 
     // Connect to the database
+    console.log(`${flags.db} connection url`);
     const client = await MongoClient.connect(flags.db);
     await client.connect();
 

src/bundles/bundles.module.ts

@@ -4,9 +4,10 @@ import { DampLabServicesModule } from '../services/damplab-services.module';
 import { Bundle, BundleSchema } from './bundles.model';
 import { BundlesResolver } from './bundles.resolver';
 import { BundlesService } from './bundles.service';
+import { BundleUpdatePipe } from './update.pipe';
 
 @Module({
   imports: [MongooseModule.forFeature([{ name: Bundle.name, schema: BundleSchema }]), DampLabServicesModule],
-  providers: [BundlesService, BundlesResolver]
+  providers: [BundlesService, BundlesResolver, BundleUpdatePipe]
 })
 export class BundlesModule {}

src/bundles/bundles.pipe.ts

@@ -0,0 +1,17 @@
+import { Injectable, NotFoundException, PipeTransform } from '@nestjs/common';
+import { Bundle } from './bundles.model';
+import { BundlesService } from './bundles.service';
+
+@Injectable()
+export class BundlesPipe implements PipeTransform<string, Promise<Bundle>> {
+  constructor(private readonly bundleService: BundlesService) {}
+
+  async transform(value: string): Promise<Bundle> {
+    const bundle = await this.bundleService.find(value);
+
+    if (!bundle) {
+      throw new NotFoundException(`Bundle with id ${value} not found`);
+    }
+    return bundle;
+  }
+}

src/bundles/bundles.resolver.ts

@@ -1,8 +1,11 @@
-import { Parent, Query, ResolveField, Resolver } from '@nestjs/graphql';
+import { Parent, Query, ResolveField, Resolver, Args, Mutation, ID } from '@nestjs/graphql';
 import { DampLabServices } from '../services/damplab-services.services';
 import { DampLabService } from '../services/models/damplab-service.model';
 import { Bundle } from './bundles.model';
 import { BundlesService } from './bundles.service';
+import { BundlesPipe } from './bundles.pipe';
+import { BundleChange } from './dtos/update.dto';
+import { BundleUpdatePipe } from './update.pipe';
 
 @Resolver(() => Bundle)
 export class BundlesResolver {
@@ -13,6 +16,11 @@ export class BundlesResolver {
     return this.bundlesService.findAll();
   }
 
+  @Mutation(() => Bundle)
+  async updateBundle(@Args('bundle', { type: () => ID }, BundlesPipe) bundle: Bundle, @Args('changes', { type: () => BundleChange }, BundleUpdatePipe) changes: BundleChange): Promise<Bundle> {
+    return this.bundlesService.update(bundle, changes);
+  }
+
   @ResolveField()
   async services(@Parent() bundle: Bundle): Promise<DampLabService[]> {
     return this.dampLabServices.findByIds(bundle.services);

src/bundles/bundles.service.ts

@@ -2,12 +2,22 @@ import { Injectable } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Bundle } from './bundles.model';
 import { Model } from 'mongoose';
+import { BundleChange } from './dtos/update.dto';
 
 @Injectable()
 export class BundlesService {
   constructor(@InjectModel(Bundle.name) private readonly bundleModel: Model<Bundle>) {}
 
+  async find(id: string): Promise<Bundle | null> {
+    return this.bundleModel.findById(id);
+  }
+
   async findAll(): Promise<Bundle[]> {
     return this.bundleModel.find().exec();
   }
+
+  async update(bundle: Bundle, changes: BundleChange): Promise<Bundle> {
+    await this.bundleModel.updateOne({ _id: bundle.id }, changes);
+    return (await this.find(bundle.id))!;
+  }
 }

src/bundles/dtos/update.dto.ts

@@ -0,0 +1,8 @@
+import { Bundle } from '../bundles.model';
+import { ID, InputType, OmitType, PartialType, Field } from '@nestjs/graphql';
+
+@InputType()
+export class BundleChange extends PartialType(OmitType(Bundle, ['id', 'services'] as const), InputType) {
+  @Field(() => [ID], { nullable: true })
+  services: string[];
+}

src/bundles/update.pipe.ts

@@ -0,0 +1,17 @@
+import { Injectable, PipeTransform } from '@nestjs/common';
+import { DampLabServicePipe } from '../services/damplab-services.pipe';
+import { BundleChange } from './dtos/update.dto';
+
+@Injectable()
+export class BundleUpdatePipe implements PipeTransform<BundleChange, Promise<BundleChange>> {
+  constructor(private readonly damplabServicePipe: DampLabServicePipe) {}
+
+  async transform(value: BundleChange): Promise<BundleChange> {
+    // If services is includes, make sure they are all valid
+    if (value.services) {
+      await Promise.all(value.services.map((service) => this.damplabServicePipe.transform(service)));
+    }
+
+    return value;
+  }
+}

src/categories/categories.module.ts

@@ -4,9 +4,11 @@ import { Category, CategorySchema } from './category.model';
 import { CategoryService } from './categories.service';
 import { CategoryResolver } from './categories.resolver';
 import { DampLabServicesModule } from '../services/damplab-services.module';
+import { CategoryPipe } from './categories.pipe';
+import { CategoryUpdatePipe } from './update.pipe';
 
 @Module({
   imports: [MongooseModule.forFeature([{ name: Category.name, schema: CategorySchema }]), DampLabServicesModule],
-  providers: [CategoryService, CategoryResolver]
+  providers: [CategoryService, CategoryResolver, CategoryPipe, CategoryUpdatePipe]
 })
 export class CategoriesModule {}

src/categories/categories.pipe.ts

@@ -0,0 +1,19 @@
+import { NotFoundException, Injectable, PipeTransform } from '@nestjs/common';
+import { Category } from './category.model';
+import { CategoryService } from './categories.service';
+
+@Injectable()
+export class CategoryPipe implements PipeTransform<string, Promise<Category>> {
+  constructor(private readonly categoryService: CategoryService) {}
+
+  async transform(value: string): Promise<Category> {
+    try {
+      const category = await this.categoryService.find(value);
+      if (category) {
+        return category;
+      }
+    } catch (e) {}
+
+    throw new NotFoundException(`Category with id ${value} not found`);
+  }
+}

src/categories/categories.resolver.ts

@@ -1,8 +1,13 @@
-import { Query, ResolveField, Resolver } from '@nestjs/graphql';
+import { Args, Mutation, Query, ResolveField, Resolver, ID } from '@nestjs/graphql';
 import { Category } from './category.model';
 import { CategoryService } from './categories.service';
 import { DampLabServices } from '../services/damplab-services.services';
 import { DampLabService } from '../services/models/damplab-service.model';
+import { CategoryPipe } from './categories.pipe';
+import { CategoryChange } from './dtos/update.dto';
+import { CategoryUpdatePipe } from './update.pipe';
+import { CreateCategory } from './dtos/create.dto';
+import { CreateCategoryPipe } from './create.pipe';
 
 @Resolver(() => Category)
 export class CategoryResolver {
@@ -13,6 +18,25 @@ export class CategoryResolver {
     return this.categoryService.findAll();
   }
 
+  @Mutation(() => Category)
+  async updateCategory(
+    @Args('category', { type: () => ID }, CategoryPipe) category: Category,
+    @Args('changes', { type: () => CategoryChange }, CategoryUpdatePipe) changes: CategoryChange
+  ): Promise<Category> {
+    return this.categoryService.update(category, changes);
+  }
+
+  @Mutation(() => Boolean)
+  async deleteCategory(@Args('category', { type: () => ID }, CategoryPipe) category: Category): Promise<boolean> {
+    await this.categoryService.delete(category);
+    return true;
+  }
+
+  @Mutation(() => Category)
+  async createCategory(@Args('category', CreateCategoryPipe) category: CreateCategory): Promise<Category> {
+    return this.categoryService.create(category);
+  }
+
   /**
    * Resolver for the services field of the Category type
    */

src/categories/categories.service.ts

@@ -2,6 +2,8 @@ import { Injectable } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Category, CategoryDocument } from './category.model';
 import { Model } from 'mongoose';
+import { CategoryChange } from './dtos/update.dto';
+import { CreateCategory } from './dtos/create.dto';
 
 @Injectable()
 export class CategoryService {
@@ -10,4 +12,21 @@ export class CategoryService {
   async findAll(): Promise<Category[]> {
     return this.categoryModel.find().exec();
   }
+
+  async find(id: string): Promise<Category | null> {
+    return this.categoryModel.findById(id);
+  }
+
+  async update(category: Category, change: CategoryChange): Promise<Category> {
+    await this.categoryModel.updateOne({ _id: category._id }, change);
+    return (await this.find(category._id))!;
+  }
+
+  async delete(category: Category): Promise<void> {
+    await this.categoryModel.deleteOne({ _id: category._id });
+  }
+
+  async create(category: CreateCategory): Promise<Category> {
+    return this.categoryModel.create(category);
+  }
 }

src/categories/create.pipe.ts

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

src/categories/dtos/create.dto.ts

@@ -0,0 +1,8 @@
+import { ID, InputType, OmitType, Field } from '@nestjs/graphql';
+import { Category } from '../category.model';
+
+@InputType()
+export class CreateCategory extends OmitType(Category, ['_id', 'services'] as const, InputType) {
+  @Field(() => [ID])
+  services: string[];
+}

src/categories/dtos/update.dto.ts

@@ -0,0 +1,8 @@
+import { Category } from '../category.model';
+import { ID, OmitType, PartialType, Field, InputType } from '@nestjs/graphql';
+
+@InputType()
+export class CategoryChange extends PartialType(OmitType(Category, ['_id', 'services'] as const), InputType) {
+  @Field(() => [ID], { nullable: true })
+  services: string[];
+}

src/categories/update.pipe.ts

@@ -0,0 +1,17 @@
+import { Injectable, PipeTransform } from '@nestjs/common';
+import { DampLabServicePipe } from '../services/damplab-services.pipe';
+import { CategoryChange } from './dtos/update.dto';
+
+@Injectable()
+export class CategoryUpdatePipe implements PipeTransform<CategoryChange, Promise<CategoryChange>> {
+  constructor(private readonly damplabServicePipe: DampLabServicePipe) {}
+
+  async transform(value: CategoryChange): Promise<CategoryChange> {
+    // If services is includes, make sure they are all valid
+    if (value.services) {
+      await Promise.all(value.services.map((service) => this.damplabServicePipe.transform(service)));
+    }
+
+    return value;
+  }
+}

src/reset/dtos/service.dto.ts

@@ -29,4 +29,7 @@ export class ServiceInput {
 
   @Field(() => [String], { nullable: true })
   resultParams?: string[];
+
+  @Field(() => JSON, { nullable: true })
+  paramGroups?: any[];
 }

src/reset/reset.service.ts

@@ -60,7 +60,8 @@ export class ResetService {
         allowedConnections: [],
         result: service.result,
         description: service.description,
-        resultParams: service.resultParams
+        resultParams: service.resultParams,
+        paramGroups: service.paramGroups
       });
 
       // Update the map

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,13 +1,15 @@
 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';
 import { DampLabService, DampLabServiceSchema } from './models/damplab-service.model';
+import { ServiceUpdatePipe } from './update.pipe';
 
 @Module({
   imports: [MongooseModule.forFeature([{ name: DampLabService.name, schema: DampLabServiceSchema }])],
-  providers: [DampLabServicesResolver, DampLabServices, DampLabServicePipe],
+  providers: [DampLabServicesResolver, DampLabServices, DampLabServicePipe, ServiceUpdatePipe, CreateServicePipe],
   exports: [DampLabServices, DampLabServicePipe]
 })
 export class DampLabServicesModule {}