prisma-generator-postgres-realtime

Prisma Generator Pothos Codegen

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

Install

Using yarn

yarn add -D prisma-generator-pothos-codegen

or using npm

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

Peer dependencies

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

"@pothos/core": "^3.41.0",
"@pothos/plugin-prisma": "^3.65.0",
"@prisma/client": "^5.15.1",
"prisma": "^5.15.1",

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

Set Up

Add the generator to your schema.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

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<Prisma.Decimal, Prisma.InputJsonValue | null, Prisma.InputJsonValue>; // required to define correct types for created scalars.
}>({
  // Other builder config
});

Create a configuration file (optional)

// ./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: {
  },
};

Click to see all configuration options

{
  /** Input type generation config */
  inputs?: {
    /** Create simpler inputs for easier customization and ~65% less generated code. Default: `false` */
    simple?: boolean;
    /** How to import the Prisma namespace. Default: `"import { Prisma } from '.prisma/client';"` */
    prismaImporter?: string;
    /** Path to generate the inputs file to from project root. Default: `'./generated/inputs.ts'` */
    outputFilePath?: string;
    /** List of excluded scalars from generated output */
    excludeScalars?: string[];
    /** A function to replace generated source. Combined with global replacer config */
    replacer?: Replacer<'inputs'>;
    /** Map all Prisma fields with "@id" attribute to Graphql "ID" Scalar.
     *
     * ATTENTION: Mapping non String requires a conversion inside resolver, once GraphQl ID Input are coerced to String by definition. Default: false */
    mapIdFieldsToGraphqlId?: false | 'WhereUniqueInputs';
  };
  /** CRUD generation config */
  crud?: {
    /** Disable generaton of crud. Default: `false` */
    disabled?: boolean;
    /** How to import the inputs. Default `"import * as Inputs from '../inputs';"` */
    inputsImporter?: string;
    /** How to import the Prisma namespace at the objects.ts file. Default `"import { Prisma } from '.prisma/client';"`. Please use "resolverImports" to import prismaClient at resolvers. */
    prismaImporter?: string;
    /** How to call the prisma client. Default `'_context.prisma'` */
    prismaCaller?: string;
    /** Any additional imports you might want to add to the resolvers (e.g. your prisma client). Default: `''` */
    resolverImports?: string;
    /** Directory to generate crud code into from project root. Default: `'./generated'` */
    outputDir?: string;
    /** A function to replace generated source. Combined with global replacer config */
    replacer?: Replacer<'crud'>;
    /** A boolean to enable/disable generation of `autocrud.ts` which can be imported in schema root to auto generate all crud objects, queries and mutations. Default: `true` */
    generateAutocrud?: boolean;
    /** An array of parts of resolver names to be excluded from generation. Ie: ["User"] Default: [] */
    excludeResolversContain?: string[];
    /** An array of resolver names to be excluded from generation. Ie: ["upsertOneComment"] Default: [] */
    excludeResolversExact?: string[];
    /** An array of parts of resolver names to be included from generation (to bypass exclude contain). Ie: if exclude ["User"], include ["UserReputation"] Default: [] */
    includeResolversContain?: string[];
    /** An array of resolver names to be included from generation (to bypass exclude contain). Ie: if exclude ["User"], include ["UserReputation"] Default: [] */
    includeResolversExact?: string[];
    /** Caution: This delete the whole folder (Only use if the folder only has auto generated contents). A boolean to delete output dir before generate. Default: False */
    deleteOutputDirBeforeGenerate?: boolean;
    /** Export all crud queries/mutations/objects in objects.ts at root dir. Default: true */
    exportEverythingInObjectsDotTs?: boolean;
    /** Map all Prisma fields with "@id" attribute to Graphql "ID" Scalar. Default: 'Objects' */
    mapIdFieldsToGraphqlId?: false | 'Objects';
    /** Change the generated variables from object.base.ts from something like `UserName` to `User_Name`. This avoids generated duplicated names in some cases. See [issue #58](https://github.com/Cauen/prisma-generator-pothos-codegen/issues/58). Default: false */
    underscoreBetweenObjectVariableNames?: false | 'Objects';
  };
  /** Global config */
  global?: {
    /** A function to replace generated source */
    replacer?: Replacer;
    /** Location of builder to replace in all files. Relative to package root. ie: './src/schema/builder'. Default: './builder' */
    builderLocation?: string;
    /** Run function before generate */
    beforeGenerate?: (dmmf: DMMF.Document) => void;
    /** Run function after generate */
    afterGenerate?: (dmmf: DMMF.Document) => void;
  };
}

Run the generator

yarn prisma generate

or

npx prisma generate

Usage

Inputs

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.

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.

// ./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<Prisma.UserUpdateInput & { customArg: string }>('UserUpdateInputCustom')
  .implement({
    fields: (t) => ({
      ...UserUpdateInputFields(t),
      customArg: t.field({ required: true, type: 'String' }),
    }),
  });

Objects

// ./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!' }),
    };
  },
});

Queries and Mutations

// ./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 },
    }),
  };
});

Auto define all objects, queries and mutations (crud operations)

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

// ./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

Examples

Check for the example for a running sample

Disclosures

Models with only relations

• 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.

BigInt rename

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

Changelog

0.1.0

• [x] Feat: First version