From 824a3d28f030815318eeb080ffacd7e3d1040cf9 Mon Sep 17 00:00:00 2001 From: cbolles Date: Wed, 4 Sep 2024 13:02:16 -0400 Subject: [PATCH 1/6] Add ability to update a given service --- src/services/damplab-services.resolver.ts | 11 ++++++++++- src/services/damplab-services.services.ts | 6 ++++++ src/services/dtos/update.dto.ts | 9 +++++++++ 3 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 src/services/dtos/update.dto.ts diff --git a/src/services/damplab-services.resolver.ts b/src/services/damplab-services.resolver.ts index 6a2e02d..acfefe6 100644 --- a/src/services/damplab-services.resolver.ts +++ b/src/services/damplab-services.resolver.ts @@ -1,5 +1,7 @@ -import { Resolver, Query, ResolveField, Parent } from '@nestjs/graphql'; +import { Resolver, Query, ResolveField, Parent, ID, Args, Mutation } from '@nestjs/graphql'; +import { DampLabServicePipe } from './damplab-services.pipe'; import { DampLabServices } from './damplab-services.services'; +import { ServiceChange } from './dtos/update.dto'; import { DampLabService } from './models/damplab-service.model'; @Resolver(() => DampLabService) @@ -11,6 +13,13 @@ export class DampLabServicesResolver { return this.dampLabServices.findAll(); } + @Mutation(() => DampLabService) + async updateService( + @Args('service', { type: () => ID }, DampLabServicePipe) service: DampLabService, + @Args('changes') changes: ServiceChange): Promise { + return this.dampLabServices.update(service, changes); + } + /** * Resolver which the `allowedConnections` field of the `DampLabService` * type. Allows for the recursive search on possible connections. diff --git a/src/services/damplab-services.services.ts b/src/services/damplab-services.services.ts index 3b15030..5d9e6ed 100644 --- a/src/services/damplab-services.services.ts +++ b/src/services/damplab-services.services.ts @@ -3,6 +3,7 @@ import { DampLabService, DampLabServiceDocument } from './models/damplab-service import { InjectModel } from '@nestjs/mongoose'; import { Model } from 'mongoose'; import mongoose from 'mongoose'; +import { ServiceChange } from './dtos/update.dto'; @Injectable() export class DampLabServices { @@ -22,4 +23,9 @@ export class DampLabServices { async findOne(id: string): Promise { return this.dampLabServiceModel.findById(id).exec(); } + + async update(service: DampLabService, changes: ServiceChange): Promise { + await this.dampLabServiceModel.updateOne({ _id: service._id }, changes); + return (await this.dampLabServiceModel.findById(service._id))!; + } } diff --git a/src/services/dtos/update.dto.ts b/src/services/dtos/update.dto.ts new file mode 100644 index 0000000..45bb7d4 --- /dev/null +++ b/src/services/dtos/update.dto.ts @@ -0,0 +1,9 @@ +import { DampLabService } from '../models/damplab-service.model'; +import { ID, InputType, OmitType, PartialType, Field } from '@nestjs/graphql'; + + +@InputType() +export class ServiceChange extends PartialType(OmitType(DampLabService, ['_id', 'allowedConnections'] as const), InputType) { + @Field(() => [ID], { nullable: true }) + allowedConnections: string[]; +} From 5f817728ba548b10ba5d57ef89c5cd5d4dca3993 Mon Sep 17 00:00:00 2001 From: cbolles Date: Wed, 4 Sep 2024 13:12:56 -0400 Subject: [PATCH 2/6] Add update to bundles --- src/bundles/bundles.pipe.ts | 17 +++++++++++++++++ src/bundles/bundles.resolver.ts | 12 +++++++++++- src/bundles/bundles.service.ts | 10 ++++++++++ src/bundles/dtos/update.dto.ts | 8 ++++++++ 4 files changed, 46 insertions(+), 1 deletion(-) create mode 100644 src/bundles/bundles.pipe.ts create mode 100644 src/bundles/dtos/update.dto.ts diff --git a/src/bundles/bundles.pipe.ts b/src/bundles/bundles.pipe.ts new file mode 100644 index 0000000..e97c96b --- /dev/null +++ b/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> { + constructor(private readonly bundleService: BundlesService) {} + + async transform(value: string): Promise { + const bundle = await this.bundleService.find(value); + + if(!bundle) { + throw new NotFoundException(`Bundle with id ${value} not found`); + } + return bundle; + } +} diff --git a/src/bundles/bundles.resolver.ts b/src/bundles/bundles.resolver.ts index bbee738..bfb9368 100644 --- a/src/bundles/bundles.resolver.ts +++ b/src/bundles/bundles.resolver.ts @@ -1,8 +1,10 @@ -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'; @Resolver(() => Bundle) export class BundlesResolver { @@ -13,6 +15,14 @@ export class BundlesResolver { return this.bundlesService.findAll(); } + @Mutation(() => Bundle) + async updateBundle( + @Args('bundle', { type: () => ID }, BundlesPipe) bundle: Bundle, + @Args('changes') changes: BundleChange + ) { + return this.bundlesService.update(bundle, changes); + } + @ResolveField() async services(@Parent() bundle: Bundle): Promise { return this.dampLabServices.findByIds(bundle.services); diff --git a/src/bundles/bundles.service.ts b/src/bundles/bundles.service.ts index ff24a39..2d06d16 100644 --- a/src/bundles/bundles.service.ts +++ b/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) {} + async find(id: string): Promise { + return this.bundleModel.findById(id); + } + async findAll(): Promise { return this.bundleModel.find().exec(); } + + async update(bundle: Bundle, changes: BundleChange): Promise { + await this.bundleModel.updateOne({ _id: bundle.id }, changes); + return (await this.find(bundle.id))!; + } } diff --git a/src/bundles/dtos/update.dto.ts b/src/bundles/dtos/update.dto.ts new file mode 100644 index 0000000..712adc2 --- /dev/null +++ b/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[]; +} From 24d818f803e6c87f615809e4c224746afe2cfe59 Mon Sep 17 00:00:00 2001 From: cbolles Date: Wed, 4 Sep 2024 13:24:20 -0400 Subject: [PATCH 3/6] Add update to categories --- src/categories/categories.module.ts | 3 ++- src/categories/categories.pipe.ts | 19 +++++++++++++++++++ src/categories/categories.resolver.ts | 12 +++++++++++- src/categories/categories.service.ts | 10 ++++++++++ src/categories/dtos/update.dto.ts | 9 +++++++++ 5 files changed, 51 insertions(+), 2 deletions(-) create mode 100644 src/categories/categories.pipe.ts create mode 100644 src/categories/dtos/update.dto.ts diff --git a/src/categories/categories.module.ts b/src/categories/categories.module.ts index c3f7b37..dbc70cb 100644 --- a/src/categories/categories.module.ts +++ b/src/categories/categories.module.ts @@ -4,9 +4,10 @@ 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'; @Module({ imports: [MongooseModule.forFeature([{ name: Category.name, schema: CategorySchema }]), DampLabServicesModule], - providers: [CategoryService, CategoryResolver] + providers: [CategoryService, CategoryResolver, CategoryPipe] }) export class CategoriesModule {} diff --git a/src/categories/categories.pipe.ts b/src/categories/categories.pipe.ts new file mode 100644 index 0000000..f495ea1 --- /dev/null +++ b/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> { + constructor(private readonly categoryService: CategoryService) {} + + async transform(value: string): Promise { + try { + const category = await this.categoryService.find(value); + if (category) { + return category; + } + } catch (e) {} + + throw new NotFoundException(`Category with id ${value} not found`); + } +} diff --git a/src/categories/categories.resolver.ts b/src/categories/categories.resolver.ts index f0e46e1..8e7034e 100644 --- a/src/categories/categories.resolver.ts +++ b/src/categories/categories.resolver.ts @@ -1,8 +1,10 @@ -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'; @Resolver(() => Category) export class CategoryResolver { @@ -13,6 +15,14 @@ export class CategoryResolver { return this.categoryService.findAll(); } + @Mutation(() => Category) + async updateCategory( + @Args('category', { type: () => ID }, CategoryPipe) category: Category, + @Args('changes') changes: CategoryChange + ) { + return this.categoryService.update(category, changes); + } + /** * Resolver for the services field of the Category type */ diff --git a/src/categories/categories.service.ts b/src/categories/categories.service.ts index e0d14c1..6f65c24 100644 --- a/src/categories/categories.service.ts +++ b/src/categories/categories.service.ts @@ -2,6 +2,7 @@ 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'; @Injectable() export class CategoryService { @@ -10,4 +11,13 @@ export class CategoryService { async findAll(): Promise { return this.categoryModel.find().exec(); } + + async find(id: string): Promise { + return this.categoryModel.findById(id); + } + + async update(category: Category, change: CategoryChange): Promise { + await this.categoryModel.updateOne({ _id: category._id }, change); + return (await this.find(category._id))!; + } } diff --git a/src/categories/dtos/update.dto.ts b/src/categories/dtos/update.dto.ts new file mode 100644 index 0000000..f008943 --- /dev/null +++ b/src/categories/dtos/update.dto.ts @@ -0,0 +1,9 @@ +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[]; +} + From 3e95cb8c1c506034e3124522ad88045b7161a9f9 Mon Sep 17 00:00:00 2001 From: cbolles Date: Wed, 4 Sep 2024 13:42:04 -0400 Subject: [PATCH 4/6] Add checking to services in connection lists --- src/bundles/bundles.module.ts | 3 ++- src/bundles/bundles.resolver.ts | 3 ++- src/bundles/update.pipe.ts | 17 +++++++++++++++++ src/categories/categories.module.ts | 3 ++- src/categories/categories.resolver.ts | 3 ++- src/categories/update.pipe.ts | 18 ++++++++++++++++++ src/services/damplab-services.module.ts | 3 ++- src/services/damplab-services.resolver.ts | 3 ++- src/services/update.pipe.ts | 17 +++++++++++++++++ 9 files changed, 64 insertions(+), 6 deletions(-) create mode 100644 src/bundles/update.pipe.ts create mode 100644 src/categories/update.pipe.ts create mode 100644 src/services/update.pipe.ts diff --git a/src/bundles/bundles.module.ts b/src/bundles/bundles.module.ts index c28eee8..d8af307 100644 --- a/src/bundles/bundles.module.ts +++ b/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 {} diff --git a/src/bundles/bundles.resolver.ts b/src/bundles/bundles.resolver.ts index bfb9368..936e86f 100644 --- a/src/bundles/bundles.resolver.ts +++ b/src/bundles/bundles.resolver.ts @@ -5,6 +5,7 @@ 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 { @@ -18,7 +19,7 @@ export class BundlesResolver { @Mutation(() => Bundle) async updateBundle( @Args('bundle', { type: () => ID }, BundlesPipe) bundle: Bundle, - @Args('changes') changes: BundleChange + @Args('changes', { type: () => BundleChange }, BundleUpdatePipe) changes: BundleChange ) { return this.bundlesService.update(bundle, changes); } diff --git a/src/bundles/update.pipe.ts b/src/bundles/update.pipe.ts new file mode 100644 index 0000000..d695a49 --- /dev/null +++ b/src/bundles/update.pipe.ts @@ -0,0 +1,17 @@ +import { Injectable, PipeTransform } from '@nestjs/common'; +import { DampLabServicePipe } from 'src/services/damplab-services.pipe'; +import { BundleChange } from './dtos/update.dto'; + +@Injectable() +export class BundleUpdatePipe implements PipeTransform> { + constructor(private readonly damplabServicePipe: DampLabServicePipe) {} + + async transform(value: BundleChange): Promise { + // 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; + } +} diff --git a/src/categories/categories.module.ts b/src/categories/categories.module.ts index dbc70cb..46a604e 100644 --- a/src/categories/categories.module.ts +++ b/src/categories/categories.module.ts @@ -5,9 +5,10 @@ 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, CategoryPipe] + providers: [CategoryService, CategoryResolver, CategoryPipe, CategoryUpdatePipe] }) export class CategoriesModule {} diff --git a/src/categories/categories.resolver.ts b/src/categories/categories.resolver.ts index 8e7034e..18b9dcc 100644 --- a/src/categories/categories.resolver.ts +++ b/src/categories/categories.resolver.ts @@ -5,6 +5,7 @@ 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'; @Resolver(() => Category) export class CategoryResolver { @@ -18,7 +19,7 @@ export class CategoryResolver { @Mutation(() => Category) async updateCategory( @Args('category', { type: () => ID }, CategoryPipe) category: Category, - @Args('changes') changes: CategoryChange + @Args('changes', { type: () => CategoryChange }, CategoryUpdatePipe) changes: CategoryChange ) { return this.categoryService.update(category, changes); } diff --git a/src/categories/update.pipe.ts b/src/categories/update.pipe.ts new file mode 100644 index 0000000..3bedece --- /dev/null +++ b/src/categories/update.pipe.ts @@ -0,0 +1,18 @@ +import { Injectable, PipeTransform } from '@nestjs/common'; +import { DampLabServicePipe } from 'src/services/damplab-services.pipe'; +import { CategoryChange } from './dtos/update.dto'; + + +@Injectable() +export class CategoryUpdatePipe implements PipeTransform> { + constructor(private readonly damplabServicePipe: DampLabServicePipe) {} + + async transform(value: CategoryChange): Promise { + // 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; + } +} diff --git a/src/services/damplab-services.module.ts b/src/services/damplab-services.module.ts index f5717f1..8011782 100644 --- a/src/services/damplab-services.module.ts +++ b/src/services/damplab-services.module.ts @@ -4,10 +4,11 @@ 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], exports: [DampLabServices, DampLabServicePipe] }) export class DampLabServicesModule {} diff --git a/src/services/damplab-services.resolver.ts b/src/services/damplab-services.resolver.ts index acfefe6..8f25589 100644 --- a/src/services/damplab-services.resolver.ts +++ b/src/services/damplab-services.resolver.ts @@ -3,6 +3,7 @@ import { DampLabServicePipe } from './damplab-services.pipe'; import { DampLabServices } from './damplab-services.services'; import { ServiceChange } from './dtos/update.dto'; import { DampLabService } from './models/damplab-service.model'; +import { ServiceUpdatePipe } from './update.pipe'; @Resolver(() => DampLabService) export class DampLabServicesResolver { @@ -16,7 +17,7 @@ export class DampLabServicesResolver { @Mutation(() => DampLabService) async updateService( @Args('service', { type: () => ID }, DampLabServicePipe) service: DampLabService, - @Args('changes') changes: ServiceChange): Promise { + @Args('changes', { type: () => ServiceChange }, ServiceUpdatePipe) changes: ServiceChange): Promise { return this.dampLabServices.update(service, changes); } diff --git a/src/services/update.pipe.ts b/src/services/update.pipe.ts new file mode 100644 index 0000000..12947aa --- /dev/null +++ b/src/services/update.pipe.ts @@ -0,0 +1,17 @@ +import { Injectable, PipeTransform } from '@nestjs/common'; +import { DampLabServicePipe } from 'src/services/damplab-services.pipe'; +import { ServiceChange } from './dtos/update.dto'; + +@Injectable() +export class ServiceUpdatePipe implements PipeTransform> { + constructor(private readonly damplabServicePipe: DampLabServicePipe) {} + + async transform(value: ServiceChange): Promise { + // If services is includes, make sure they are all valid + if (value.allowedConnections) { + await Promise.all(value.allowedConnections.map(service => this.damplabServicePipe.transform(service))); + } + + return value; + } +} From 406a58f46409878c77ff0cad46b0009c43c5740b Mon Sep 17 00:00:00 2001 From: cbolles Date: Wed, 4 Sep 2024 13:43:37 -0400 Subject: [PATCH 5/6] Fix formatting --- src/bundles/bundles.pipe.ts | 2 +- src/bundles/bundles.resolver.ts | 5 +---- src/bundles/update.pipe.ts | 2 +- src/categories/categories.resolver.ts | 2 +- src/categories/dtos/update.dto.ts | 1 - src/categories/update.pipe.ts | 3 +-- src/services/damplab-services.resolver.ts | 3 ++- src/services/dtos/update.dto.ts | 1 - src/services/update.pipe.ts | 2 +- 9 files changed, 8 insertions(+), 13 deletions(-) diff --git a/src/bundles/bundles.pipe.ts b/src/bundles/bundles.pipe.ts index e97c96b..466fbc4 100644 --- a/src/bundles/bundles.pipe.ts +++ b/src/bundles/bundles.pipe.ts @@ -9,7 +9,7 @@ export class BundlesPipe implements PipeTransform> { async transform(value: string): Promise { const bundle = await this.bundleService.find(value); - if(!bundle) { + if (!bundle) { throw new NotFoundException(`Bundle with id ${value} not found`); } return bundle; diff --git a/src/bundles/bundles.resolver.ts b/src/bundles/bundles.resolver.ts index 936e86f..ea21235 100644 --- a/src/bundles/bundles.resolver.ts +++ b/src/bundles/bundles.resolver.ts @@ -17,10 +17,7 @@ export class BundlesResolver { } @Mutation(() => Bundle) - async updateBundle( - @Args('bundle', { type: () => ID }, BundlesPipe) bundle: Bundle, - @Args('changes', { type: () => BundleChange }, BundleUpdatePipe) changes: BundleChange - ) { + async updateBundle(@Args('bundle', { type: () => ID }, BundlesPipe) bundle: Bundle, @Args('changes', { type: () => BundleChange }, BundleUpdatePipe) changes: BundleChange): Promise { return this.bundlesService.update(bundle, changes); } diff --git a/src/bundles/update.pipe.ts b/src/bundles/update.pipe.ts index d695a49..2422487 100644 --- a/src/bundles/update.pipe.ts +++ b/src/bundles/update.pipe.ts @@ -9,7 +9,7 @@ export class BundleUpdatePipe implements PipeTransform { // If services is includes, make sure they are all valid if (value.services) { - await Promise.all(value.services.map(service => this.damplabServicePipe.transform(service))); + await Promise.all(value.services.map((service) => this.damplabServicePipe.transform(service))); } return value; diff --git a/src/categories/categories.resolver.ts b/src/categories/categories.resolver.ts index 18b9dcc..6d2a35a 100644 --- a/src/categories/categories.resolver.ts +++ b/src/categories/categories.resolver.ts @@ -20,7 +20,7 @@ export class CategoryResolver { async updateCategory( @Args('category', { type: () => ID }, CategoryPipe) category: Category, @Args('changes', { type: () => CategoryChange }, CategoryUpdatePipe) changes: CategoryChange - ) { + ): Promise { return this.categoryService.update(category, changes); } diff --git a/src/categories/dtos/update.dto.ts b/src/categories/dtos/update.dto.ts index f008943..d8742d3 100644 --- a/src/categories/dtos/update.dto.ts +++ b/src/categories/dtos/update.dto.ts @@ -6,4 +6,3 @@ export class CategoryChange extends PartialType(OmitType(Category, ['_id', 'serv @Field(() => [ID], { nullable: true }) services: string[]; } - diff --git a/src/categories/update.pipe.ts b/src/categories/update.pipe.ts index 3bedece..727d407 100644 --- a/src/categories/update.pipe.ts +++ b/src/categories/update.pipe.ts @@ -2,7 +2,6 @@ import { Injectable, PipeTransform } from '@nestjs/common'; import { DampLabServicePipe } from 'src/services/damplab-services.pipe'; import { CategoryChange } from './dtos/update.dto'; - @Injectable() export class CategoryUpdatePipe implements PipeTransform> { constructor(private readonly damplabServicePipe: DampLabServicePipe) {} @@ -10,7 +9,7 @@ export class CategoryUpdatePipe implements PipeTransform { // If services is includes, make sure they are all valid if (value.services) { - await Promise.all(value.services.map(service => this.damplabServicePipe.transform(service))); + await Promise.all(value.services.map((service) => this.damplabServicePipe.transform(service))); } return value; diff --git a/src/services/damplab-services.resolver.ts b/src/services/damplab-services.resolver.ts index 8f25589..5013466 100644 --- a/src/services/damplab-services.resolver.ts +++ b/src/services/damplab-services.resolver.ts @@ -17,7 +17,8 @@ export class DampLabServicesResolver { @Mutation(() => DampLabService) async updateService( @Args('service', { type: () => ID }, DampLabServicePipe) service: DampLabService, - @Args('changes', { type: () => ServiceChange }, ServiceUpdatePipe) changes: ServiceChange): Promise { + @Args('changes', { type: () => ServiceChange }, ServiceUpdatePipe) changes: ServiceChange + ): Promise { return this.dampLabServices.update(service, changes); } diff --git a/src/services/dtos/update.dto.ts b/src/services/dtos/update.dto.ts index 45bb7d4..2084491 100644 --- a/src/services/dtos/update.dto.ts +++ b/src/services/dtos/update.dto.ts @@ -1,7 +1,6 @@ import { DampLabService } from '../models/damplab-service.model'; import { ID, InputType, OmitType, PartialType, Field } from '@nestjs/graphql'; - @InputType() export class ServiceChange extends PartialType(OmitType(DampLabService, ['_id', 'allowedConnections'] as const), InputType) { @Field(() => [ID], { nullable: true }) diff --git a/src/services/update.pipe.ts b/src/services/update.pipe.ts index 12947aa..e247c07 100644 --- a/src/services/update.pipe.ts +++ b/src/services/update.pipe.ts @@ -9,7 +9,7 @@ export class ServiceUpdatePipe implements PipeTransform { // If services is includes, make sure they are all valid if (value.allowedConnections) { - await Promise.all(value.allowedConnections.map(service => this.damplabServicePipe.transform(service))); + await Promise.all(value.allowedConnections.map((service) => this.damplabServicePipe.transform(service))); } return value; From abf6507511d680ca466f15fb69901b5755c033d7 Mon Sep 17 00:00:00 2001 From: cbolles Date: Wed, 4 Sep 2024 13:46:23 -0400 Subject: [PATCH 6/6] Fix import style --- src/bundles/update.pipe.ts | 2 +- src/categories/update.pipe.ts | 2 +- src/services/update.pipe.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/bundles/update.pipe.ts b/src/bundles/update.pipe.ts index 2422487..b6e2453 100644 --- a/src/bundles/update.pipe.ts +++ b/src/bundles/update.pipe.ts @@ -1,5 +1,5 @@ import { Injectable, PipeTransform } from '@nestjs/common'; -import { DampLabServicePipe } from 'src/services/damplab-services.pipe'; +import { DampLabServicePipe } from '../services/damplab-services.pipe'; import { BundleChange } from './dtos/update.dto'; @Injectable() diff --git a/src/categories/update.pipe.ts b/src/categories/update.pipe.ts index 727d407..6ff1fd8 100644 --- a/src/categories/update.pipe.ts +++ b/src/categories/update.pipe.ts @@ -1,5 +1,5 @@ import { Injectable, PipeTransform } from '@nestjs/common'; -import { DampLabServicePipe } from 'src/services/damplab-services.pipe'; +import { DampLabServicePipe } from '../services/damplab-services.pipe'; import { CategoryChange } from './dtos/update.dto'; @Injectable() diff --git a/src/services/update.pipe.ts b/src/services/update.pipe.ts index e247c07..8341ed4 100644 --- a/src/services/update.pipe.ts +++ b/src/services/update.pipe.ts @@ -1,5 +1,5 @@ import { Injectable, PipeTransform } from '@nestjs/common'; -import { DampLabServicePipe } from 'src/services/damplab-services.pipe'; +import { DampLabServicePipe } from '../services/damplab-services.pipe'; import { ServiceChange } from './dtos/update.dto'; @Injectable()