Relations persistence

[mborgues]

Hello,
I would like to know if it is possible or if so how to include child records in a mutation, is it possible? Are there any examples or topics in the documentation about it?

example:

mutation{
  createOneXpto(input: {
    xptoDto:{
      id:1
      dataOne: "xpto"
      dataDate:"2024-12-06T13:32:14-03:00"
      xptoChild1:{
        id: 1
        idXpto:1
        descriptionXptoChild: "xpto child 1"
     }
   }
  }) {
    id
}

[TriPSs]

Good question, I don't know, if you tried it let me know. After checking locally I think this should be possible.

[mborgues]

LOL,

I managed to include the child records, I created the reference of the child input in the main input always using the name of the property as it is found in the main DTO relationship, the relationship in the main entity must be marked as {cascade: true}, the child input does not need to have the key fields, they are filled in automatically even with codes generated in the inclusion, and that's it, inclusion completed.

Child input without key fields:

DTO relation:

Input Relation:

Entity relation with cacade true:

Mutation:

Logs:

The data:

[vane-tec]

Including Child Records in a GraphQL Mutation

Steps to Configure Parent-Child Relationships

1. Define DTOs

Define the parent and child DTOs using the @Relation decorator.

import { ObjectType, Field, ID, InputType } from '@nestjs/graphql';
import { Relation } from '@nestjs-query/query-graphql';

@ObjectType('Xpto')
@InputType('XptoInput')
export class XptoDTO {
  @Field(() => ID)
  id: number;

  @Field()
  dataOne: string;

  @Field()
  dataDate: Date;

  @Relation('xptoChild1', () => XptoChildDTO, { nullable: true })
  xptoChild1?: XptoChildDTO;
}

@ObjectType('XptoChild')
@InputType('XptoChildInput')
export class XptoChildDTO {
  @Field(() => ID)
  id: number;

  @Field(() => ID)
  idXpto: number;

  @Field()
  descriptionXptoChild: string;
}

2. Configure Services

Ensure that your services support relationships. If using @nestjs-query/query-typeorm, relationships are automatically managed if they are configured in your entities.

3. Configure Mutations

Create a mutation in your GraphQL resolver to handle inserting parent and child data.

import { Resolver, Mutation, Args } from '@nestjs/graphql';
import { XptoDTO } from './xpto.dto';
import { XptoService } from './xpto.service';

@Resolver(() => XptoDTO)
export class XptoResolver {
  constructor(private readonly xptoService: XptoService) {}

  @Mutation(() => XptoDTO)
  async createOneXpto(@Args('input') input: XptoDTO): Promise<XptoDTO> {
    return this.xptoService.create(input);
  }
}

4. Example Mutation Query

Once configured, you can run the following mutation to insert parent and child records:

mutation {
  createOneXpto(input: {
    id: 1,
    dataOne: "xpto",
    dataDate: "2024-12-06T13:32:14-03:00",
    xptoChild1: {
      id: 1,
      idXpto: 1,
      descriptionXptoChild: "xpto child 1"
    }
  }) {
    id
    dataOne
    dataDate
    xptoChild1 {
      id
      descriptionXptoChild
    }
  }
}

[vane-tec]

Using @FilterCursorConnection for Parent-Child Relations in GraphQL

Steps to Configure

1. Define DTOs with @FilterCursorConnection

The @FilterCursorConnection decorator allows you to define a relation and automatically enables filtering and pagination for that relation.

import { ObjectType, Field, ID, InputType } from '@nestjs/graphql';
import { FilterableField, FilterCursorConnection } from '@nestjs-query/query-graphql';

@ObjectType('Xpto')
@InputType('XptoInput')
export class XptoDTO {
  @FilterableField(() => ID)
  id: number;

  @FilterableField()
  dataOne: string;

  @FilterableField()
  dataDate: Date;

  @FilterCursorConnection('xptoChild1', () => XptoChildDTO, { nullable: true })
  xptoChild1?: XptoChildDTO[];
}

@ObjectType('XptoChild')
@InputType('XptoChildInput')
export class XptoChildDTO {
  @FilterableField(() => ID)
  id: number;

  @FilterableField(() => ID)
  idXpto: number;

  @FilterableField()
  descriptionXptoChild: string;
}

2. Configure Entities

Ensure the TypeORM entities reflect the relationships.

import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
import { XptoEntity } from './xpto.entity';

@Entity('xpto_child')
export class XptoChildEntity {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  idXpto: number;

  @Column()
  descriptionXptoChild: string;

  @ManyToOne(() => XptoEntity, (xpto) => xpto.xptoChild1)
  xpto: XptoEntity;
}

@Entity('xpto')
export class XptoEntity {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  dataOne: string;

  @Column()
  dataDate: Date;
}

3. Configure GraphQL Module

Ensure the GraphQLModule is set up to use @nestjs-query/query-graphql.

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { XptoResolver } from './xpto.resolver';
import { XptoService } from './xpto.service';

@Module({
  imports: [
    GraphQLModule.forRoot({
      autoSchemaFile: true,
    }),
  ],
  providers: [XptoResolver, XptoService],
})
export class XptoModule {}

4. Mutation Example

You can now create a mutation to handle the parent and child creation.

mutation {
  createOneXpto(input: {
    id: 1,
    dataOne: "xpto",
    dataDate: "2024-12-06T13:32:14-03:00",
    xptoChild1: [{
      id: 1,
      idXpto: 1,
      descriptionXptoChild: "xpto child 1"
    }]
  }) {
    id
    dataOne
    xptoChild1 {
      id
      descriptionXptoChild
    }
  }
}

Benefits of Using @FilterCursorConnection

Simplified Configuration: Automatically handles filtering and pagination for child entities.

GraphQL Consistency: Standardized way to expose relationships in the API.

Flexibility: Supports advanced queries and nested filtering directly in the GraphQL query.


By leveraging @FilterCursorConnection, you can streamline the implementation of parent-child relations and avoid custom resolver logic for common use cases.