Prisma Generator Pothos Codegen

!Group 1

A prisma generator plugin that auto-generates Pothos GraphQL input types and crud operations (all queries and mutations).

Easily convert a prisma schema into a full graphql CRUD API.

On prisma generate we create:

- All input types for Create, Find, Update, Sort and Delete operations (to be used as args in fields).
- (Optional): Create all Objects, Queries and Mutations base files (to create customizable resolvers).
- (Optional): Execute all these base files without customization to create a default CRUD.

Table of Contents

- Getting Started
* Install
* Peer dependencies
* Set Up
+ Add the generator to your schema.prisma
+ Add scalar types to the builder
+ Create a configuration file (optional)
+ Run the generator
- Usage
* Inputs
* Objects
* Queries and Mutations
* Auto define all objects, queries and mutations (crud operations)
* Examples
- Disclosures
* Models with only relations
* BigInt rename

Getting Started

$3

Using yarn

``sh
yarn add -D prisma-generator-pothos-codegen
`

or using npm

`sh
npm install --save-dev prisma-generator-pothos-codegen
`

$3

The package has been developed and tested up to the following peer dependencies (see updated example):

`
"@pothos/core": "^4.0.2",
"@pothos/plugin-prisma": "^4.0.3"",
"@prisma/client": "^5.15.1",
"prisma": "^5.15.1",
`

Using higher versions may break something. In these cases, please open a new issue.

$3

#### Add the generator to your schema.prisma

`prisma
generator client {
provider = "prisma-client-js"
}

generator pothos {
provider = "prisma-pothos-types"
}

generator pothosCrud {
provider = "prisma-generator-pothos-codegen"
generatorConfigPath = "./pothos.config.js"
// You may also set the generatorConfigPath via the POTHOS_CRUD_CONFIG_PATH environment variable.
// The environment variable will override the path hardcoded here.
}

/// This is a user!
model User {
/// This is an id!
id String @id
}
`

#### Add scalar types to the builder

`ts
import { Scalars } from 'prisma-generator-pothos-codegen';
import { Prisma } from '.prisma/client';

export const builder = new SchemaBuilder<{
// ... Context, plugins? ...
PrismaTypes: PrismaTypes; // required for @pothos/plugin-prisma integration (which is required)
Scalars: Scalars; // required to define correct types for created scalars.
}>({
// Other builder config
});
`

#### Create a configuration file (optional)

`js
// ./pothos.config.js

/* @type {import('prisma-generator-pothos-codegen').Config} /
module.exports = {
inputs: {
outputFilePath: './src/graphql/__generated__/inputs.ts',
},
crud: {
outputDir: './src/graphql/__generated__/',
inputsImporter: import * as Inputs from '@graphql/__generated__/inputs';,
resolverImports: import prisma from '@lib/prisma';,
prismaCaller: 'prisma',
},
global: {
},
};
`

`sh
yarn prisma generate
`

or

`sh
npx prisma generate
`

Usage

$3

You can use @Pothos.omit() function calls in your prisma schema field descriptions to control which fields are used in the generated input types.

- @Pothos.omit() Omits the field from all inputs
- @Pothos.omit(create) Omits field from the create input
- @Pothos.omit(orderBy, where, update) Omits field from the orderBy, where, and update inputs, but not the create input

The available options are create, update, where, and orderBy.

`prisma
model User {
/// @Pothos.omit(create, update)
id String @id @default(uuid())
email String
/// @Pothos.omit()
password String
}
`

You can also augment/derive new inputs from the generated inputs.ts file.

`ts
// ./src/graphql/User/inputs.ts

import { Prisma } from '@prisma/client';
// Import generated input fields definition
import { UserUpdateInputFields } from '@/graphql/__generated__/inputs';

// Note: you can't use builder.inputType to generate this new input
export const UserUpdateInputCustom = builder
.inputRef('UserUpdateInputCustom')
.implement({
fields: (t) => ({
...UserUpdateInputFields(t),
customArg: t.field({ required: true, type: 'String' }),
}),
});
`

$3

`ts
// ./src/graphql/User/object.ts

import { UserObject } from '@/graphql/__generated__/User';
import { builder } from '@/graphql/builder'; // Pothos schema builder

// Use the Object export to accept all default generated query code
builder.prismaObject('User', UserObject);

// Or modify it as you wish
builder.prismaObject('User', {
...UserObject,
fields: (t) => {
// Type-safely omit and rename fields
const { password: _password, email: emailAddress, ...fields } = UserObject.fields(t);
const sessionsField = UserSessionsFieldObject(t);

return {
...fields,
// Renamed field
emailAddress,
// Edit and extend field
sessions: t.relation('sessions', {
...sessionsField,
args: { ...sessionsField.args, customArg: t.arg({ type: 'String', required: false }) },
authScopes: { admin: true },
}),
// Add custom fields
customField: t.field({ type: 'String', resolve: () => 'Hello world!' }),
};
},
});
`

$3

`ts
// ./src/graphql/User/query.ts

import { findManyUserQuery, findManyUserQueryObject } from '@/graphql/__generated__/User';
import { builder } from '@/graphql/builder'; // Pothos schema builder

// Use the Query exports to accept all default generated query code
builder.queryFields(findManyUserQuery);

// Use the QueryObject exports to override or add to the generated code
builder.queryFields((t) => {
const field = findManyUserQueryObject(t);
return {
findManyUser: t.prismaField({
// Inherit all the generated properties
...field,

// Modify the args and use custom arg in a custom resolver
args: { ...field.args, customArg: t.arg({ type: 'String', required: false }) },
resolve: async (query, root, args, context, info) => {
const { customArg } = args;
console.log(customArg);
return field.resolve(query, root, args, context, info);
},

// Add an custom extension
authScopes: { admin: true },
}),
};
});
`

$3

First, make sure that options.crud.generateAutocrud isn't set to false

`ts
// ./src/schema/index.ts (import autocrud.ts)
import {
generateAllCrud,
generateAllObjects,
generateAllQueries,
generateAllMutations
} from '@/graphql/__generated__/autocrud.ts',
import { builder } from '@/graphql/builder'; // Pothos schema builder

// (option 1) generate all objects, queries and mutations
generateAllCrud()

// (option 2) or create them separately
generateAllObjects()
generateAllQueries()
generateAllMutations()

// (option 3) or limit crud generation
generateAllObjects({ include: ["User", "Profile", 'Comment'] })
generateAllQueries({ exclude: ["Comment"] })
generateAllMutations({ exclude: ["User"] })

// Defining schema roots
builder.queryType({});
builder.mutationType({});

export const schema = builder.toSchema({});
`

Generated queries:

- count
- findFirst
- findMany
- findUnique

Generated mutations:

- createMany
- createOne
- deleteMany
- deleteOne
- updateMany
- updateOne
- upsertOne

$3

Check for the example for a running sample

!image

Disclosures

$3

- We create a custom scalar NEVER that avoids this error: Input Object type FollowUpdateManyMutationInput must define one or more fields. from Graphql. if you have models that are relations-only. Like N-N fields without no relation fields or id-only models, we set field _ of some operations to this scalar. If you fill this fake property, the operation will result in a error.

$3

- As BigInt is reserved, we export Bigint` for the BigInt scalar.