How to expose relations in custom endpoints

[epenflow]

I’ve been using nestjs-query for a while, but I’m confused about how to expose and fetch relations when using custom endpoints. I could finds any guidance on the documentation. Could someone provide guidance on this.?

event.resolver.ts

import { InjectQueryService, QueryService } from '@nestjs-query/core';
import {
    ArrayConnectionType,
    CRUDResolver,
    CursorConnectionType,
    OffsetConnectionType,
    Relation,
} from '@nestjs-query/query-graphql';
import {
    HttpException,
    HttpStatus,
    Inject,
    Logger,
    UseGuards,
} from '@nestjs/common';
import { Args, Context, ID, Query, Resolver } from '@nestjs/graphql';
import { JwtService } from '@nestjs/jwt';
import { InjectRepository } from '@nestjs/typeorm';
import { OrganizationRole } from 'src/common/decorators';
import { EventEntity, OrganizationEntity } from 'src/common/entities';
import { EventDetailsType, EventType } from 'src/common/graphql';
import {
    EventDetailsArgs,
    EventDetailsConnection,
    EventTypeArgs,
    EventTypeConnection,
} from 'src/common/graphql/args/event.args';
import { JWTAuthGuard, RolesGuard } from 'src/common/guards';
import { GqlContext, JWTPayload } from 'src/common/interfaces';
import { Repository } from 'typeorm';

@Resolver(() => EventDetailsType)
export class EventResolver {
    private readonly logger = new Logger(EventResolver.name);
    constructor(
        @Inject(JwtService)
        private readonly jwtService: JwtService,
        @InjectRepository(OrganizationEntity)
        private readonly organizationRepository: Repository<OrganizationEntity>,
        @InjectQueryService(EventEntity)
        private readonly eventQueryService: QueryService<EventEntity>,
    ) {}

    /**
     *
     * - I want to expose the relations in this method and query all the related entities. How can I achieve this?
     */
    @Query(() => EventDetailsConnection, {
        name: `events`,
        description: `Retrieves a list of events.`,
    })
    async find(@Args() query: EventDetailsArgs) {
        const events = await this.eventQueryService.query(query);
        this.logger.debug({ events });
    }
}

event.args.ts

import {
    PagingStrategies,
    QueryArgsType,
    StaticConnectionType,
} from '@nestjs-query/query-graphql';
import { ArgsType } from '@nestjs/graphql';
import { EventDetailsType, EventType } from 'src/common/graphql/type';

@ArgsType()
export class EventTypeArgs extends QueryArgsType(EventType) {}
export const EventTypeConnection: StaticConnectionType<
    EventType,
    PagingStrategies
> = EventTypeArgs.ConnectionType;

@ArgsType()
export class EventDetailsArgs extends QueryArgsType(EventDetailsType) {}
export const EventDetailsConnection: StaticConnectionType<
    EventDetailsType,
    PagingStrategies
> = EventDetailsArgs.ConnectionType;

event.type.ts

import {
    FilterableField,
    IDField,
    Relation,
} from '@nestjs-query/query-graphql';
import { Field, GraphQLISODateTime, ID, ObjectType } from '@nestjs/graphql';
import { GraphQLString } from 'graphql';
import { OrganizationType } from 'src/common/graphql/type/organization.type';

@ObjectType('Event')
export class EventType {
    @IDField(() => ID, {
        description: `The unique identifier of the event.`,
    })
    id: string;

    @Field(() => GraphQLString, {
        description: `The name of the event.`,
    })
    name!: string;

    @Field(() => GraphQLString, {
        description: `The descriptions of the event.`,
        nullable: true,
    })
    descriptions?: string;

    @FilterableField(() => GraphQLISODateTime, {
        description: `The date and time when event was started.`,
    })
    startDateAt!: Date;

    @FilterableField(() => GraphQLISODateTime, {
        description: `The date and time when event was end.`,
    })
    endDateAt!: Date;
}

@ObjectType('EventDetails')
@Relation('organization', () => OrganizationType, {
    disableRemove: true,
    disableUpdate: true,
})
export class EventDetailsType extends EventType {}

event.entity.ts

import { OrganizationEntity } from 'src/common/entities/organization.entity';
import {
    Column,
    Entity,
    JoinColumn,
    ManyToOne,
    ObjectType,
    PrimaryGeneratedColumn,
} from 'typeorm';

@Entity({
    name: `event`,
})
export class EventEntity {
    /** Event ID */
    @PrimaryGeneratedColumn('uuid')
    id: string;

    /** Event Name */
    @Column('varchar')
    name: string;

    /** Event descriptions */
    @Column({
        type: 'text',
        nullable: true,
    })
    descriptions: string;

    /** Event Start Date */
    @Column({
        type: 'timestamp',
    })
    startDateAt: Date;
    /** Event End Date */
    @Column({
        type: 'timestamp',
    })
    endDateAt: Date;
    /** Relationship to Organization */
    @ManyToOne(
        (): ObjectType<OrganizationEntity> => OrganizationEntity,
        (organization) => organization.events,
    )
    @JoinColumn()
    organization!: OrganizationEntity;
}

organization.type.ts

import { FilterableField, IDField } from '@nestjs-query/query-graphql';
import { Field, GraphQLISODateTime, ID, ObjectType } from '@nestjs/graphql';
import { GraphQLString } from 'graphql';
import { AccountType } from 'src/common/graphql/type/account.type';
import { EventType } from 'src/common/graphql/type/event.type';

@ObjectType('Organization')
export class OrganizationType {
    @IDField(() => ID, {
        description: `The unique identifier of the organization.`,
    })
    id!: string;

    @FilterableField(() => GraphQLString, {
        description: `The name of the organization.`,
    })
    name!: string;

    @FilterableField(() => GraphQLISODateTime, {
        description: `The date and time when organization was created.`,
    })
    createdAt!: Date;

    @FilterableField(() => GraphQLISODateTime, {
        description: `The date and time when organization was updated.`,
    })
    updatedAt!: Date;
}

@ObjectType('OrganizationDetails')
export class OrganizationDetailsType extends OrganizationType {
    @Field(() => AccountType, {
        description: `The account associated with organization.`,
    })
    account: AccountType;

    @Field(() => [EventType], {
        nullable: true,
        description: `The events associated with organization.`,
    })
    events: EventType[];
}

organization.entity.ts

import { AccountEntity } from 'src/common/entities/account.entity';
import { EventEntity } from 'src/common/entities/event.entity';
import {
    Column,
    CreateDateColumn,
    Entity,
    JoinColumn,
    OneToMany,
    OneToOne,
    PrimaryGeneratedColumn,
    UpdateDateColumn,
} from 'typeorm';
@Entity({
    name: `organization`,
})
export class OrganizationEntity {
    /** ID Field */
    @PrimaryGeneratedColumn('uuid')
    id!: string;

    /** Name Field */
    @Column({
        type: 'varchar',
        length: 255,
    })
    name!: string;

    /** The date and time field when organization was generated and last updated */
    @CreateDateColumn()
    createdAt!: Date;
    @UpdateDateColumn()
    updatedAt!: Date;

    /** Relationship to account  */
    @OneToOne(() => AccountEntity, (account) => account.organization)
    @JoinColumn()
    account!: AccountEntity;

    /** Relationship to events */
    @OneToMany(() => EventEntity, (event) => event.organization)
    events: EventEntity[];
}