Merge pull request #123 from TriPSs/feature/extend-relation-update-de…

…lete

Feature/extend relation update delete

jest.preset.js

@@ -1,4 +1,4 @@
-const nxPreset = require('@nrwl/jest/preset').default;
+const nxPreset = require('@nrwl/jest/preset').default
 
 module.exports = {
   ...nxPreset,
@@ -12,17 +12,18 @@ module.exports = {
     '!**/dist/**',
     '!**/node_modules/**',
     '!**/jest.config.ts',
+    '!**/jest.e2e.ts'
   ],
   moduleNameMapper: {
     '@ptc-org/nestjs-query-core': process.cwd() + '/packages/core/src',
     '@ptc-org/nestjs-query-graphql': process.cwd() + '/packages/query-graphql/src',
     '@ptc-org/nestjs-query-typeorm': process.cwd() + '/packages/query-typeorm/src',
     '@ptc-org/nestjs-query-sequelize': process.cwd() + '/packages/query-sequelize/src',
     '@ptc-org/nestjs-query-typegoose': process.cwd() + '/packages/query-typegoose/src',
-    '@ptc-org/nestjs-query-mongoose': process.cwd() + '/packages/query-mongoose/src',
+    '@ptc-org/nestjs-query-mongoose': process.cwd() + '/packages/query-mongoose/src'
   },
   testEnvironment: 'node',
   setupFilesAfterEnv: ['jest-extended'],
   snapshotSerializers: ['jest-snapshot-serializer-raw/always'],
-  testTimeout: 10000,
+  testTimeout: 10000
 }

packages/query-graphql/src/resolvers/relations/aggregate-relations.resolver.ts

@@ -20,17 +20,15 @@ export interface AggregateRelationsResolverOpts extends RelationsOpts {
   enableAggregate?: boolean
 }
 
-type AggregateRelationOpts<Relation> = {
-  enableAggregate?: boolean
-} & ResolverRelation<Relation>
+type AggregateRelationOpts<Relation> = ResolverRelation<Relation>
 
 const AggregateRelationMixin =
   <DTO, Relation>(DTOClass: Class<DTO>, relation: AggregateRelationOpts<Relation>) =>
   <B extends Class<ServiceResolver<DTO, QueryService<DTO, unknown, unknown>>>>(Base: B): B => {
-    if (!relation.enableAggregate) {
+    if (!relation.enableAggregate && !relation.aggregate?.enabled) {
       return Base
     }
-    const commonResolverOpts = removeRelationOpts(relation)
+    const commonResolverOpts = relation.aggregate || removeRelationOpts(relation)
     const relationDTO = relation.DTO
     const dtoName = getDTONames(DTOClass).baseName
     const { baseNameLower, pluralBaseNameLower, pluralBaseName } = getDTONames(relationDTO, {
@@ -47,9 +45,17 @@ const AggregateRelationMixin =
 
     @Resolver(() => DTOClass, { isAbstract: true })
     class AggregateMixin extends Base {
-      @ResolverField(`${pluralBaseNameLower}Aggregate`, () => [AR], {}, commonResolverOpts, {
-        interceptors: [AuthorizerInterceptor(DTOClass)]
-      })
+      @ResolverField(
+        `${pluralBaseNameLower}Aggregate`,
+        () => [AR],
+        {
+          description: relation.aggregate?.description
+        },
+        commonResolverOpts,
+        {
+          interceptors: [AuthorizerInterceptor(DTOClass)]
+        }
+      )
       async [`aggregate${pluralBaseName}`](
         @Parent() dto: DTO,
         @Args() q: RelationQA,

packages/query-graphql/src/resolvers/relations/relations.interface.ts

@@ -49,17 +49,24 @@ export type ResolverRelation<Relation> = {
   disableRead?: boolean
   /**
    * Disable update relation graphql endpoints
+   * @deprecated use .update.disabled instead
    */
   disableUpdate?: boolean
+  update?: Pick<ResolverRelation<Relation>, 'description'> & ResolverMethodOpts
   /**
    * Disable remove relation graphql endpoints
+   * @deprecated use .remove.disabled instead
    */
   disableRemove?: boolean
-
+  remove?: Pick<ResolverRelation<Relation>, 'description'> & ResolverMethodOpts
   /**
    * Enable aggregation queries.
    */
   enableAggregate?: boolean
+  aggregate?: Pick<ResolverRelation<Relation>, 'description'> &
+    Omit<ResolverMethodOpts, 'disabled'> & {
+      enabled?: boolean
+    }
   /**
    * Enable look ahead mode, will join and select the relation when queried.
    */

packages/query-graphql/src/resolvers/relations/remove-relations.resolver.ts

@@ -15,10 +15,12 @@ import { RelationsOpts, ResolverRelation } from './relations.interface'
 const RemoveOneRelationMixin =
   <DTO, Relation>(DTOClass: Class<DTO>, relation: ResolverRelation<Relation>) =>
   <B extends Class<ServiceResolver<DTO, QueryService<DTO, unknown, unknown>>>>(Base: B): B => {
-    if (relation.disableRemove) {
+    // TODO:: Next major version change this to be opt-in
+    if (relation.disableRemove || relation.remove?.disabled) {
       return Base
     }
-    const commonResolverOpts = removeRelationOpts(relation)
+
+    const commonResolverOpts = relation.remove || removeRelationOpts(relation)
     const relationDTO = relation.DTO
     const dtoNames = getDTONames(DTOClass)
     const { baseNameLower, baseName } = getDTONames(relationDTO, { dtoName: relation.dtoName })
@@ -32,7 +34,16 @@ const RemoveOneRelationMixin =
 
     @Resolver(() => DTOClass, { isAbstract: true })
     class RemoveOneMixin extends Base {
-      @ResolverMutation(() => DTOClass, {}, commonResolverOpts, { interceptors: [AuthorizerInterceptor(DTOClass)] })
+      @ResolverMutation(
+        () => DTOClass,
+        {
+          description: relation.remove?.description
+        },
+        commonResolverOpts,
+        {
+          interceptors: [AuthorizerInterceptor(DTOClass)]
+        }
+      )
       async [`remove${baseName}From${dtoNames.baseName}`](
         @Args() setArgs: SetArgs,
         @ModifyRelationAuthorizerFilter(baseNameLower, {
@@ -52,10 +63,11 @@ const RemoveOneRelationMixin =
 const RemoveManyRelationsMixin =
   <DTO, Relation>(DTOClass: Class<DTO>, relation: ResolverRelation<Relation>) =>
   <B extends Class<ServiceResolver<DTO, QueryService<DTO, unknown, unknown>>>>(Base: B): B => {
-    if (relation.disableRemove) {
+    // TODO:: Next major version change this to be opt-in
+    if (relation.disableRemove || relation.remove?.disabled) {
       return Base
     }
-    const commonResolverOpts = removeRelationOpts(relation)
+    const commonResolverOpts = relation.remove || removeRelationOpts(relation)
     const relationDTO = relation.DTO
     const dtoNames = getDTONames(DTOClass)
     const { pluralBaseNameLower, pluralBaseName } = getDTONames(relationDTO, { dtoName: relation.dtoName })
@@ -69,7 +81,16 @@ const RemoveManyRelationsMixin =
 
     @Resolver(() => DTOClass, { isAbstract: true })
     class Mixin extends Base {
-      @ResolverMutation(() => DTOClass, {}, commonResolverOpts, { interceptors: [AuthorizerInterceptor(DTOClass)] })
+      @ResolverMutation(
+        () => DTOClass,
+        {
+          description: relation.remove?.description
+        },
+        commonResolverOpts,
+        {
+          interceptors: [AuthorizerInterceptor(DTOClass)]
+        }
+      )
       async [`remove${pluralBaseName}From${dtoNames.baseName}`](
         @Args() addArgs: AddArgs,
         @ModifyRelationAuthorizerFilter(pluralBaseNameLower, {

packages/query-graphql/src/resolvers/relations/update-relations.resolver.ts

@@ -15,10 +15,11 @@ import { RelationsOpts, ResolverRelation } from './relations.interface'
 const UpdateOneRelationMixin =
   <DTO, Relation>(DTOClass: Class<DTO>, relation: ResolverRelation<Relation>) =>
   <B extends Class<ServiceResolver<DTO, QueryService<DTO, unknown, unknown>>>>(Base: B): B => {
-    if (relation.disableUpdate) {
+    // TODO:: Next major version change this to be opt-in
+    if (relation.disableUpdate || relation.update?.disabled) {
       return Base
     }
-    const commonResolverOpts = removeRelationOpts(relation)
+    const commonResolverOpts = relation.update || removeRelationOpts(relation)
     const relationDTO = relation.DTO
     const dtoNames = getDTONames(DTOClass)
     const { baseNameLower, baseName } = getDTONames(relationDTO, { dtoName: relation.dtoName })
@@ -32,9 +33,16 @@ const UpdateOneRelationMixin =
 
     @Resolver(() => DTOClass, { isAbstract: true })
     class UpdateOneMixin extends Base {
-      @ResolverMutation(() => DTOClass, {}, commonResolverOpts, {
-        interceptors: [AuthorizerInterceptor(DTOClass)]
-      })
+      @ResolverMutation(
+        () => DTOClass,
+        {
+          description: relation.update?.description
+        },
+        commonResolverOpts,
+        {
+          interceptors: [AuthorizerInterceptor(DTOClass)]
+        }
+      )
       async [`set${baseName}On${dtoNames.baseName}`](
         @Args() setArgs: SetArgs,
         @ModifyRelationAuthorizerFilter(baseNameLower, {
@@ -54,10 +62,11 @@ const UpdateOneRelationMixin =
 const UpdateManyRelationMixin =
   <DTO, Relation>(DTOClass: Class<DTO>, relation: ResolverRelation<Relation>) =>
   <B extends Class<ServiceResolver<DTO, QueryService<DTO, unknown, unknown>>>>(Base: B): B => {
-    if (relation.disableUpdate) {
+    // TODO:: Next major version change this to be opt-in
+    if (relation.disableUpdate || relation.update?.disabled) {
       return Base
     }
-    const commonResolverOpts = removeRelationOpts(relation)
+    const commonResolverOpts = relation.update || removeRelationOpts(relation)
     const relationDTO = relation.DTO
     const dtoNames = getDTONames(DTOClass)
     const { pluralBaseNameLower, pluralBaseName } = getDTONames(relationDTO, { dtoName: relation.dtoName })
@@ -77,9 +86,16 @@ const UpdateManyRelationMixin =
 
     @Resolver(() => DTOClass, { isAbstract: true })
     class UpdateManyMixin extends Base {
-      @ResolverMutation(() => DTOClass, {}, commonResolverOpts, {
-        interceptors: [AuthorizerInterceptor(DTOClass)]
-      })
+      @ResolverMutation(
+        () => DTOClass,
+        {
+          description: relation.update?.description
+        },
+        commonResolverOpts,
+        {
+          interceptors: [AuthorizerInterceptor(DTOClass)]
+        }
+      )
       async [`add${pluralBaseName}To${dtoNames.baseName}`](
         @Args() addArgs: AddArgs,
         @ModifyRelationAuthorizerFilter(pluralBaseNameLower, {