prisma-generator-nestjs-graphql-crud v2.5.5

prisma-generator-nestjs-graphql-crud

This prisma generator will create all the @nestjs/graphql classes you'll need for basic CRUD operations; based on your prisma schema. It includes dataloader to prevent the infamous n+1 problem in graphql.

npm i prisma-generator-nestjs-graphql-crud

Getting Started

1. Inside your prisma schema add the following:

generator nestJsGraphQlCrud {
  provider = "prisma-generator-nestjs-graphql-crud"
}

Options:

2. Configure your Graphql Service In NestJs

The generated code relies on the context object for graphql to contain a reference to the prisma client. See the use of useFactory in the GraphQLModule below.

PrismaModule and PrismaService are generated; if you want your own custom implementation, use this doc as a guide.

* generated code is compatible with @nestjs/mercurius, @nestjs/apollo and @graphql-yoga/nestjs

import {
  DataLoaderService,
  PrismaModule,
  prismaProviders,
  PrismaService
} from '@generated/graphql';
import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';

@Module({
  imports: [
    GraphQLModule.forRootAsync<ApolloDriverConfig>({
      driver: ApolloDriver,
      inject: [DataLoaderService, PrismaService],
      useFactory: (loaders: DataLoaderService, prisma: PrismaService) => ({
        autoSchemaFile: 'schema.gql',
        context: (req: FastifyRequest, res: FastifyReply) => {
          return {
            loaders: loaders.create(),
            prisma,
            req,
            res
          };
        },
        graphiql: true
      })
    }),
    PrismaModule.forRoot({
      isGlobal: true
    })
  ],
  providers: [...prismaProviders]
})
export class AppModule {
}

Prisma Features

The following are the various filters and generated resolvers. Note the table name is Upper-CamelCased; e.g. user_session would become UserSession.

• Filters
• Resolvers

Resolvers

All the following are based on the example project found here.

• create
• createMany
• delete
• deleteMany
• findFirst
• findMany
• findUnique
• update
• updateMany

create

Create a new entity. Here's an example:

mutation {
    createTodo(title: "Next Todo", userId: 1) {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "createTodo": {
      "id": 6,
      "title": "Next Todo",
      "userId": 1
    }
  }
}

createMany

Create multiple new entities. Here's an example:

mutation {
    createManyTodo([{"title": "Another Todo", "userId": 1}, {"title": "Final Todo", "userId": 2}]) {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "createManyTodo": [
      {
        "id": 7,
        "title": "Another Todo",
        "userId": 1
      },
      {
        "id": 8,
        "title": "Final Todo",
        "userId": 2
      }
    ]
  }
}

delete

Delete an entity. Here's an example:

mutation {
    deleteTodo(id: 1) {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "deleteTodo": {
      "id": 1,
      "title": "First Todo",
      "userId": 1
    }
  }
}

deleteMany

Delete multiple entities. Here's an example:

mutation {
    deleteManyTodo(userId: 1) {
        id
        title
        userId
    }
}

This returns the list of deleted todos:

{
  "data": {
    "deleteManyTodo": [
      {
        "id": 1,
        "title": "First Todo",
        "userId": 1
      },
      {
        "id": 2,
        "title": "Second Todo",
        "userId": 1
      }
    ]
  }
}

findFirst

Find first should be used when you want to query and find a single row without using any of the unique keys for filters; this means that any filters you use for a findMany can be used here. Here's an example:

query {
    findFirstTodo(title: "That Todo") {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "findFirstTodo": {
      "id": 1,
      "title": "That Todo",
      "userId": 1
    }
  }
}

findMany

Find many is used to return either filtered or unfiltered rows from a table, and can optionally provide skip (offset) and take (limit) as parameters to control pagination. Here's an example:

query {
    findManyTodo(skip: 0, take: 5) {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "findManyTodo": [
      {
        "id": 1,
        "title": "Todo 1",
        "userId": 1
      },
      {
        "id": 2,
        "title": "Todo 2",
        "userId": 1
      },
      {
        "id": 3,
        "title": "Todo 3",
        "userId": 1
      },
      {
        "id": 4,
        "title": "Todo 4",
        "userId": 2
      },
      {
        "id": 5,
        "title": "Todo 5",
        "userId": 2
      }
    ]
  }
}

findUnique

Find unique should be used when you want to query against a primary key or composite key. Here's an example:

query {
    findUniqueTodo(id: 1) {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "findUniqueTodo": {
      "id": 1,
      "title": "Todo 1",
      "userId": 1
    }
  }
}

update

Updates a single entity. Here's an example:

mutation {
    updateTodo(data: {"title": "First Todo", "userId": 2}, where: {"id": 1}) {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "updateTodo": {
      "id": 1,
      "title": "First Todo",
      "userId": 2
    }
  }
}

updateMany

Updates a single entity. Here's an example:

mutation {
    updateManyTodo(data: {"userId": 2}, where: {"userId": 1}) {
        id
        title
        userId
    }
}

This would return the following:

{
  "data": {
    "updateManyTodo": [
      {
        "id": 1,
        "title": "First Todo",
        "userId": 2
      },
      {
        "id": 2,
        "title": "Second Todo",
        "userId": 2
      }
    ]
  }
}

Filters

The following filters are available are:

• DateFilter
• NumberFilter
• OrderBy
• Skip
• StringFilter
• Take

DateFilter

Options

Example:

query {
    findManyTodo(createdAt: { gt: "2022-01-10", lt: "2023-01-10" }) {
        id
        title
    }
}

NumberFilter

Options

Example:

query {
    findManyTodo(userId: { gt: 1, lt: 2 }) {
        id
        title
        userId
    }
}

OrderBy

Example:

query {
    findManyTodo(skip: 0, take: 5, orderBy: {title: "desc"}) {
        id
        title
    }
}

StringFilter

Options

*all are case-insensitive

Example:

query {
    findManyTodo(title: { contains: "First" }) {
        id
        title
    }
}

Skip (offset)

Example:

query {
    findManyTodo(skip: 0) {
        id
        title
    }
}

Take (limit)

Example:

query {
    findManyTodo(take: 10) {
        id
        title
    }
}

Graphql Features

Example

See a generated example here; note, when the output is in a node_modules directory, it will automatically transpile cjs and mjs versions.

Road Map

• authentication guard integration
• cursor-based pagination
• expand gt, gte, lt, lte, notIn, in, not "where" filtering to types other than DateTime, Int, and String

TODO

• fix orderBy ArgTypes casting to Prisma.{Model}FindManyArgs['orderBy']
• fix data ArgTypes casting to Prisma.{Model}CreateArgs['data']
• fix where ArgTypes casting to Prisma.{Model}FindManyArgs['where']