feat: prisma typed select

[magrinj]

This PR removes some relation resolvers using PrismaSelect from PalJS.
The PrismaSelect class is able to extract fields required from GraphQLResolveInfo.
This one is working fine, but one problem of this library is the lack of type support prisma-tools/#260.

Because Prisma doesn't export a map that makes a relation between model name and select interfaces, I've added a script that generates this type mapping.
This one is called each time we regenerate the Prisma client.

The API in place uses a decorator to extract select from GraphQLResolveInfo.
This decorator calls PrismaSelect under the hood.

1. Basic way to use it

@UseGuards(JwtAuthGuard)a
@Resolver(() => Pipeline)
export class PipelineResolver {
  constructor(private readonly pipelineService: PipelineService) {}

  @Query(() => [Pipeline])
  @UseGuards(AbilityGuard)
  @CheckAbilities(ReadPipelineAbilityHandler)
  async findManyPipeline(
    @Args() args: FindManyPipelineArgs,
    @UserAbility() ability: AppAbility,
    @PrismaSelector({ modelName: 'Pipeline' }) // <-- New PrismaSelector decorator to use
    prismaSelect: PrismaSelect<'Pipeline'>, // <-- Fully typed PrismaSelect
  ): Promise<Partial<Pipeline>[]> {
    return this.pipelineService.findMany({
      ...args,
      where: {
        ...args.where,
        AND: [accessibleBy(ability).Pipeline],
      },
      select: prismaSelect.value,
    });
  }
}

In the above example, we simply extract the select from the prismaSelect class using value.

2. Use it with pagination

@UseGuards(JwtAuthGuard)
@Resolver(() => Pipeline)
export class PipelineResolver {
  constructor(private readonly pipelineService: PipelineService) {}

  @Query(() => PaginatedPipeline)
  @UseGuards(AbilityGuard)
  @CheckAbilities(ReadPipelineAbilityHandler)
  async findManyPipeline(
    @Args() args: FindManyPipelineArgs,
    @UserAbility() ability: AppAbility,
    @PrismaSelector({ modelName: 'Pipeline' }) // <-- New PrismaSelector decorator to use
    prismaSelect: PrismaSelect<'Pipeline'>, // <-- Fully typed PrismaSelect
  ): Promise<PaginatedPipeline> {
    return findManyCursorConnection(
      async (findManyArgs) => {
        const results = await this.pipelineService.findMany({
          ...findManyArgs,
          select: prismaSelect.valueOf('edges.node'),
          where: whereInput,
          orderBy,
        });

        return results;
      },
      () => this.pipelineService.count(where),
      connectionArgs,
    );
  }
}

Here, because we're using pagination, we need to let PrismaSelect know from where the select needs to be extracted with valueOf.
valueOf can also be used with a second argument specifying a modelName like this: valueOf('edges.node', 'PipelineStage'). That way, we're extracting the select of PipelineStage only, which is a relation of Pipeline.