nexus-plugin-prisma: Property 'model' does not exist on type 'ObjectDefinitionBlock..., Property 'crud' does not exist on type 'OutputDefinitionBlock...

i had the same problem (model and crud properties do not exist on types) and @djm’s solution while wasn’t perfect for me pointed me to the right direction (thanks!).

my versions are:

• nexus: 1.0.0
• nexus-plugin-prisma: 0.28.0
• @prisma/client: 2.14.0
• typescript: 4.1.3
• ts-node-dev: 1.1.1

in my understanding there are 3 different type generations in play:

type generation

prisma types

yarn prisma generate provides this and the file’s location is node_modules/.prisma/client/index.ts (it took some time while i figured out that .prisma is not a typo 😄). this is strictly prisma related and it’s useful when you manually call prisma in your resolver (e.g. prisma.yourModel.findMany()).

nexus plugin prisma types

the nexusPrisma() plugin imported from the nexus-plugin-prisma package generates this. you can set the path by adding an outputs option to the plugin (e.g. nexusPrisma({ outputs: 'yourPath' })) but since the default path is node_modules/@types/typegen-nexus-plugin-prisma/index.d.ts typescript already knows about this so it’s not necessary to set this value. the file contains the types for the graphqlized prisma schema, like interfaces for the models, inputs, etc.

nexus types

the makeSchema() function imported from the nexus package generates this. this is where the missing properties are. you can set the path by adding outputs or outputs/typegen option to the config (e.g. makeSchema({ outputs: true })). there are a few different scenarios now:

1. { outputs: true }

i went with this originally because it says true means default paths and the default path for generated types is node_modules/@types/nexus-typegen/index.d.ts. unfortunately there is no generated file in node_modules because the typegen file path is not set, it remains null.

2. { outputs: { typegen: true } }

same goes for this, while the interface allows using a boolean here, it gets completely ignored.

3. { outputs: { typegen: 'yourPath' } }

in my experience this is the only working setup to make it work. with this you can set the file name of the missing generated types.

solutions

now that we finally know how to generate those types we have different ways to make typescript discover them.

leverage the node_modules/@types directory

since typescript is aware of the content of this directory and this is what nexus would do by default according to the tsdoc tag i added this to my makeSchema config:

makeSchema({
  plugins: [nexusPrisma()],
  types: [/* ... */],
  sourceTypes: {
    modules: [
      {
        module: require.resolve('.prisma/client/index.d.ts'),
        alias: 'prisma'
      }
    ]
  },
  contextType: { /* ... */ },
  outputs: {
    schema: true, // means schema.graphql in the root
    typegen: join(
      process.cwd(),
      'node_modules/@types/nexus-typegen-custom/index.d.ts'
    )
  }
})

i added the -custom prefix to prevent collision with the hopefully-soon-to-be-fixed default path.

add the generated file to tsconfig.json

i guess some people uses the official guide to make this work so here is another way to solve it:

makeSchema({
  plugins: [nexusPrisma()],
  types: [/* ... */],
  sourceTypes: {
    modules: [
      {
        module: require.resolve('.prisma/client/index.d.ts'),
        alias: 'prisma'
      }
    ]
  },
  contextType: { /* ... */ },
  outputs: {
    schema: true, // means schema.graphql in the root
    typegen: path.join(__dirname, 'generated/nexus.d.ts')
  }
})

add typeRoots to tsconfig.json under compilerOptions (your path to the generated directory can be different):

{
  "compilerOptions": {
    "typeRoots": ["./src/generated"]
  }
}

edit: now that i checked all of this again it seems like generating the nexus.d.ts outside of node_modules/@types works without adding typeRoots to my tsconfig.json. it did not work before and i spent some time with this so i could have added something to my config (can it be the rootDir?). i’m somewhat new to typescript so please fix me if i said something stupid above.

workaround At the first start, the types have not yet been defined, and then the crud and the model will have any type. But after generating the types (“nexus:reflect”: “NEXUS_SHOULD_EXIT_AFTER_REFLECTION=true ts-node src”), they will get the desired type.

// helper.ts
import { ObjectDefinitionBlock } from '@nexus/schema/dist/definitions/objectType';

type PickType<T, K extends string> = T extends Pick<any, K> ? T[K] : any;

type CRUD<TypeName extends string> = PickType<NexusGenCustomOutputProperties<TypeName>, 'crud'>;

type Model<TypeName extends string> = PickType<NexusGenCustomOutputProperties<TypeName>, 'model'>;

export const crud = <TypeName extends string>(t: ObjectDefinitionBlock<TypeName>): CRUD<TypeName> =>
  (t as any).crud;

export const model = <TypeName extends string>(
  t: ObjectDefinitionBlock<TypeName>
): Model<TypeName> => (t as any).model;

// api/graphql/User.ts
import { objectType, extendType } from '@nexus/schema'
import { crud, model } from '.../helper.ts'

export const User = objectType({
  name: 'User',
  definition(t) {
    model(t).email()
    model(t).name()
/*
   model(t).email().name()
*/
  }
})

export const UserQuery = extendType({
  type: 'Query',
  definition(t) {
    crud(t).users()
  },
})

// tsconfig.json
{
  "compilerOptions": {},
  "include": [
    "./typegen.d.ts", // <------ **TYPEGEN**
    "./src"
  ],
}

// src/index.ts
const schema = makeSchema({
  typegenAutoConfig: {
    sources: [
      {
        source: require.resolve('.prisma/client/index.d.ts'),
        alias: 'prisma',
      },
      {
        source: require.resolve('./context'),
        alias: 'ContextModule',
      },
    ],
    contextType: 'ContextModule.Context',
  },
  outputs: {
    schema: path.join(__dirname, '../schema.graphql'),
    typegen: path.join(__dirname, '../typegen.d.ts'), // <--- **TYPEGEN**
  },
  types: [types, jsonScalar, dateTimeScalar],
  shouldExitAfterGenerateArtifacts: Boolean(process.env.NEXUS_SHOULD_EXIT_AFTER_REFLECTION),
  plugins: [nexusPrisma({ experimentalCRUD: true, paginationStrategy: 'prisma' })],
});

@jawosis I think the doc is a bit unclear. My problem was that ctx.db is not passed to apollo server. I solve is by passing context:

// db.tx
import { PrismaClient } from "@prisma/client";

export const db = new PrismaClient();

// app.tx
import { db } from "./db";

const apollo = new ApolloServer({
  schema,
  context: () => ({
    db,
  }),
});

I tried the fix from this PR: https://github.com/graphql-nexus/nexus-plugin-prisma/pull/876

and everything seems to be working well now. seems to be a typo in a function in the transformer.

might be related to this error I see when running: ts-node-dev --transpile-only src/app.ts

TypeError: Cannot read property 'some' of undefined
    at transformArg (/Users/arubaito/thelab/pedra/azul/node_modules/nexus-plugin-prisma/src/dmmf/transformer.ts:91:33)