group.resolver.ts

import {Args, Mutation, Parent, Query, ResolveField, Resolver} from "@nestjs/graphql";
import {Group} from "./models/group.model";
import {PrismaService} from "../prisma/prisma.service";
import {GraphQLString} from "graphql";
import seedWords from 'mnemonic-words';
import {NotFoundException} from "@nestjs/common";

@Resolver(() => Group)
export class GroupResolver {

    constructor(
        private prismaService: PrismaService,
    ) {}

    @Mutation(() => Group)
    async createGroup(
        @Args({ name: 'name', type: () => GraphQLString }) name: string,
    ) {
        function generateWord() {
            return seedWords[Math.round(Math.random() * seedWords.length)];
        }

        const code = [generateWord(), generateWord(), generateWord(), generateWord()].join('-');

        return this.prismaService.group.create({
            data: {
                name,
                code,
            },
        });
    }

    @Query(() => Group)
    async getGroup(
        @Args({ name: 'code', type: () => GraphQLString }) code: string,
    ) {
        const group = this.prismaService.group.findFirst({
            where: { code },
            include: { unlocks: true },
        });

        if (!group)
            throw new NotFoundException();

        return group;
    }

    @ResolveField('unlocks')
    async unlocks(@Parent() group: Group) {
        const result = await this.prismaService.group.findFirst({
            where: { id: group.id },
            select: { unlocks: true },
        });

        return result.unlocks;
    }

}