@pothos/plugin-prisma 0.15.1 → 0.16.2

package/lib/util/map-includes.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryFromInfo = exports.includesFromSelectionSet = void 0;
+exports.queryFromInfo = exports.includesFromSelectionSet = exports.SELF_RELATION = void 0;
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable no-param-reassign */
 /* eslint-disable no-continue */
-/* eslint-disable @typescript-eslint/no-use-before-define */
 const graphql_1 = require("graphql");
 const values_1 = require("graphql/execution/values");
 const loader_map_1 = require("../loader-map");
 const _1 = require(".");
+exports.SELF_RELATION = '@self';
 function handleField(ctx, info, fields, selection, includes, counts, mappings, indirectMap) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     if (selection.name.value.startsWith('__')) {
         return;
     }
@@ -56,7 +56,7 @@ function handleField(ctx, info, fields, selection, includes, counts, mappings, i
         const args = (0, values_1.getArgumentValues)(field, selection, info.variableValues);
         query = query(args, ctx);
     }
-    const existingInclude = includes[relationName];
+    const existingInclude = relationName === exports.SELF_RELATION ? { include: includes } : includes[relationName];
     query = { ...query, include: newIncludes };
     if (typeof existingInclude === 'object') {
         query = (0, _1.mergeIncludes)(existingInclude, query);
@@ -64,20 +64,36 @@ function handleField(ctx, info, fields, selection, includes, counts, mappings, i
             return;
         }
     }
+    if (!mappings[relationName]) {
+        mappings[relationName] = [];
+    }
     const nestedIncludes = query.include;
     const nestedMappings = {};
     const nestedCounts = {
         current: {},
         parent: counts.current,
     };
-    if (!mappings[relationName]) {
-        mappings[relationName] = [];
+    if (relationName === exports.SELF_RELATION) {
+        mappings[relationName].push({
+            field: selection.name.value,
+            alias: (_j = selection.alias) === null || _j === void 0 ? void 0 : _j.value,
+            mappings: nestedMappings,
+            indirectPath: (_k = indirectMap === null || indirectMap === void 0 ? void 0 : indirectMap.path) !== null && _k !== void 0 ? _k : [],
+        });
+        const { include } = query;
+        if (selection.selectionSet) {
+            includesFromSelectionSet(ctx, type, info, includes, counts, nestedMappings, selection.selectionSet);
+        }
+        Object.keys(include).forEach((key) => {
+            includes[key] = include[key];
+        });
+        return;
     }
     mappings[relationName].push({
         field: selection.name.value,
-        alias: (_j = selection.alias) === null || _j === void 0 ? void 0 : _j.value,
+        alias: (_l = selection.alias) === null || _l === void 0 ? void 0 : _l.value,
         mappings: nestedMappings,
-        indirectPath: (_k = indirectMap === null || indirectMap === void 0 ? void 0 : indirectMap.path) !== null && _k !== void 0 ? _k : [],
+        indirectPath: (_m = indirectMap === null || indirectMap === void 0 ? void 0 : indirectMap.path) !== null && _m !== void 0 ? _m : [],
     });
     if (selection.selectionSet) {
         includesFromSelectionSet(ctx, type, info, nestedIncludes, nestedCounts, nestedMappings, selection.selectionSet);

package/lib/util/map-includes.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-includes.js","sourceRoot":"","sources":["../../src/util/map-includes.ts"],"names":[],"mappings":";;;AAAA,yCAAyC;AACzC,sCAAsC;AACtC,gCAAgC;AAChC,4DAA4D;AAC5D,qCAQiB;AACjB,qDAA6D;AAC7D,8CAAkD;AAQlD,wBAAuD;AAEvD,SAAS,WAAW,CAClB,GAAW,EACX,IAAwB,EACxB,MAAyC,EACzC,SAAoB,EACpB,QAAoB,EACpB,MAAqB,EACrB,QAAwB,EACxB,WAA6B;;IAE7B,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;QACzC,OAAO;KACR;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAE3C,IAAI,CAAC,KAAK,EAAE;QACV,MAAM,IAAI,KAAK,CAAC,iBAAiB,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;KAC1D;IAED,MAAM,SAAS,GAAG,MAAA,KAAK,CAAC,UAAU,0CAAE,yBAA+C,CAAC;IACpF,MAAM,eAAe,GAAG,MAAA,KAAK,CAAC,UAAU,0CAAE,kCAE7B,CAAC;IACd,MAAM,YAAY,GAAG,MAAA,KAAK,CAAC,UAAU,0CAAE,oBAA0C,CAAC;IAElF,IAAI,SAAS,EAAE;QACb,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;KAClC;IAED,IAAI,eAAe,EAAE;QACnB,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;KACvC;IAED,IAAI,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,SAAS,CAAC,MAAM,EAAE;QACjC,MAAM,QAAQ,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QAE1C,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1D,MAAM,IAAI,GAAG,IAAA,sBAAY,EAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAEtC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAAE;gBAClC,MAAM,IAAI,SAAS,CAAC,YAAY,KAAK,CAAC,IAAI,UAAU,QAAQ,CAAC,IAAI,YAAY,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;aAC3F;YAED,wBAAwB,CACtB,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,CAAC,YAAY,EACtB,WAAW,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;gBAC9B,CAAC,CAAC;oBACE,SAAS,EAAE,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;oBACzC,IAAI,EAAE,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,MAAA,MAAA,SAAS,CAAC,KAAK,0CAAE,KAAK,mCAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC;iBAC5E;gBACH,CAAC,CAAC,SAAS,CACd,CAAC;SACH;QAED,OAAO;KACR;IAED,IAAI,CAAC,YAAY,EAAE;QACjB,OAAO;KACR;IAED,MAAM,IAAI,GAAG,IAAA,sBAAY,EAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACtC,MAAM,WAAW,GAAG,IAAA,sBAAmB,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAEpD,MAAM,WAAW,GAAe;QAC9B,GAAI,MAAA,WAAW,CAAC,UAAU,0CAAE,mBAAkC;KAC/D,CAAC;IAEF,IAAI,KAAK,GAAG,MAAA,MAAA,KAAK,CAAC,UAAU,0CAAE,iBAAiB,mCAAI,EAAE,CAAC;IAEtD,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE;QAC/B,MAAM,IAAI,GAAG,IAAA,0BAAiB,EAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,cAAc,CAGnE,CAAC;QAEF,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;KAC1B;IAED,MAAM,eAAe,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IAE/C,KAAK,GAAG,EAAE,GAAI,KAAY,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAEnD,IAAI,OAAO,eAAe,KAAK,QAAQ,EAAE;QACvC,KAAK,GAAG,IAAA,gBAAa,EAAC,eAAe,EAAE,KAAgC,CAAC,CAAC;QAEzE,IAAI,CAAC,KAAK,EAAE;YACV,OAAO;SACR;KACF;IAED,MAAM,cAAc,GAAI,KAAiC,CAAC,OAAO,CAAC;IAClE,MAAM,cAAc,GAAmB,EAAE,CAAC;IAC1C,MAAM,YAAY,GAAkB;QAClC,OAAO,EAAE,EAAE;QACX,MAAM,EAAE,MAAM,CAAC,OAAO;KACvB,CAAC;IAEF,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE;QAC3B,QAAQ,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;KAC7B;IAED,QAAQ,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC;QAC1B,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,KAAK;QAC3B,KAAK,EAAE,MAAA,SAAS,CAAC,KAAK,0CAAE,KAAK;QAC7B,QAAQ,EAAE,cAAc;QACxB,YAAY,EAAE,MAAA,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,IAAI,mCAAI,EAAE;KACtC,CAAC,CAAC;IAEH,IAAI,SAAS,CAAC,YAAY,EAAE;QAC1B,wBAAwB,CACtB,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,cAAc,EACd,YAAY,EACZ,cAAc,EACd,SAAS,CAAC,YAAY,CACvB,CAAC;KACH;IAED,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;QAChD,cAAc,CAAC,MAAM,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC;KAC1D;IAED,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;QAC5C,OAAQ,KAA+B,CAAC,OAAO,CAAC;KACjD;IAED,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,KAAW,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAE,KAAiC,CAAC,CAAC,CAAC,IAAI,CAAC;AACpF,CAAC;AAED,SAAgB,wBAAwB,CACtC,GAAW,EACX,IAAsB,EACtB,IAAwB,EACxB,QAAoB,EACpB,MAAqB,EACrB,QAAwB,EACxB,YAA8B,EAC9B,eAAiC;;IAEjC,MAAM,eAAe,GAAG,MAAA,IAAI,CAAC,UAAU,0CAAE,2BAE5B,CAAC;IAEd,MAAM,WAAW,GAAG,eAAe;QACjC,CAAC,CAAC;YACE,IAAI,EAAE,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC;YAC/B,SAAS,EACP,eAAe,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;gBAClC,CAAC,CAAC,eAAe,CAAC,SAAS;gBAC3B,CAAC,CAAC,MAAA,eAAe,aAAf,eAAe,uBAAf,eAAe,CAAE,IAAI,mCAAI,EAAE;SAClC;QACH,CAAC,CAAC,eAAe,IAAI,EAAE,SAAS,EAAE,MAAA,eAAe,CAAC,IAAI,mCAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAE3E,MAAM,iBAAiB,GACrB,WAAW;QACX,CAAA,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,SAAS,CAAC,MAAM,IAAG,CAAC;QACjC,CAAA,MAAA,WAAW,CAAC,SAAS,0CAAE,MAAM,IAAG,CAAC;QACjC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAEhC,MAAM,YAAY,GAAG,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAEvF,IAAI,CAAC,CAAC,YAAY,YAAY,2BAAiB,CAAC,EAAE;QAChD,MAAM,IAAI,SAAS,CAAC,0CAA0C,CAAC,CAAC;KACjE;IAED,KAAK,MAAM,SAAS,IAAI,YAAY,CAAC,UAAU,EAAE;QAC/C,QAAQ,SAAS,CAAC,IAAI,EAAE;YACtB,KAAK,OAAO;gBACV,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,EAAE;oBAC5B,SAAS;iBACV;gBAED,WAAW,CACT,GAAG,EACH,IAAI,EACJ,IAAI,CAAC,SAAS,EAAE,EAChB,SAAS,EACT,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,WAAW,CACZ,CAAC;gBACF,MAAM;YACR,KAAK,gBAAgB;gBACnB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;oBACzC,MAAM,IAAI,KAAK,CAAC,oBAAoB,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;iBAC7D;gBAED,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,KAAK,YAAY,CAAC,IAAI,EAAE;oBACvF,SAAS;iBACV;gBAED,wBAAwB,CACtB,GAAG,EACH,YAAY,EACZ,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,YAAY,EACjD,WAAW,CACZ,CAAC;gBACF,MAAM;YACR,KAAK,gBAAgB;gBACnB,IAAI,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,KAAK,YAAY,CAAC,IAAI,EAAE;oBACvF,SAAS;iBACV;gBAED,wBAAwB,CACtB,GAAG,EACH,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,EAC7C,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,CAAC,YAAY,EACtB,WAAW,CACZ,CAAC;gBACF,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,6BAA8B,SAA8B,CAAC,IAAI,EAAE,CAAC,CAAC;SACxF;KACF;AACH,CAAC;AA9FD,4DA8FC;AAED,SAAgB,aAAa,CAAC,GAAW,EAAE,IAAwB,EAAE,QAAiB;;IACpF,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAC5B,MAAM,WAAW,GAAG,IAAA,sBAAmB,EAAC,IAAA,sBAAY,EAAC,IAAI,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC;IAE7E,MAAM,QAAQ,GAAe;QAC3B,GAAI,MAAA,WAAW,CAAC,UAAU,0CAAE,mBAAkC;KAC/D,CAAC;IAEF,MAAM,MAAM,GAAG;QACb,MAAM,EAAE,EAAE;QACV,OAAO,EAAE,EAAE;KACZ,CAAC;IAEF,MAAM,QAAQ,GAAmB,EAAE,CAAC;IACpC,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE;QAC7B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,SAAS;SACV;QAED,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAA,sBAAY,EAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAE3F,wBAAwB,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;KAC1F;IAED,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;QAC1C,QAAQ,CAAC,MAAM,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;KAC9C;IAED,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;QACpC,IAAI,QAAQ,EAAE;YACZ,IAAA,8BAAiB,EAAC,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;SAC7C;QAED,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;KAC9B;IAED,OAAO,EAAE,CAAC;AACZ,CAAC;AArCD,sCAqCC"}
+{"version":3,"file":"map-includes.js","sourceRoot":"","sources":["../../src/util/map-includes.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pothos/plugin-prisma",
-  "version": "0.15.1",
+  "version": "0.16.2",
   "description": "A Pothos plugin for more efficient integration with prisma",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -47,12 +47,13 @@
     "typescript": ">4.5.2"
   },
   "devDependencies": {
-    "@pothos/core": "^3.0.0",
-    "@pothos/plugin-errors": "^3.0.0",
-    "@pothos/plugin-relay": "^3.0.0",
-    "@pothos/test-utils": "^1.0.0",
+    "@pothos/core": "3.1.2",
+    "@pothos/plugin-errors": "3.0.1",
+    "@pothos/plugin-relay": "3.2.0",
+    "@pothos/plugin-scope-auth": "3.0.1",
+    "@pothos/test-utils": "1.0.0",
     "@prisma/client": "^3.8.1",
-    "graphql": "16.2.0",
+    "graphql": "16.3.0",
     "graphql-tag": "^2.12.6",
     "prisma": "^3.8.1"
   },
@@ -66,5 +67,5 @@
     "esm:extensions": "ts-node --compiler-options \"{\\\"module\\\":\\\"commonjs\\\"}\" ../../.config/esm-transformer.ts",
     "test": "pnpm jest --runInBand"
   },
-  "readme": "# Prisma Plugin for Pothos\n\nThis plugin provides tighter integration with prisma, making it easier to define prisma based object\ntypes, and helps solve n+1 queries for relations. It also has integrations for the relay plugin to\nmake defining nodes and connections easy and efficient.\n\n## Disclaimers\n\nThis plugin is experimental, and will have some breaking changes in the future. DO NOT USE this\nplugin unless you are willing to deal with breaking changes in upcoming versions. This plugin may\nintroduce BREAKING changes in minor versions until it's major version has been increased above 0.\n\nThis plugin is NOT required to build graphs backed by prisma models, and I would not recommend using\nit unless you have a solid understanding of how it will construct queries.\n\nThis plugin will allow common queries to be resolved through a single prisma query (prisma may still\nturn this into multiple SQL queries), and provides reasonable, predictable and safe fallbacks for\nmore complex queries and edge cases. That being said, graphql APIs are complex, and it is important\nto understand the queries your API is capable of executing.\n\nThe way this plugin resolves queries is designed to be efficient, while still being predictable and\neasy to understand. Tools that try to automatically generate queries are often hard to understand\nand reason about, so this plugin tries to make things as clear as possible by providing query\noptions to resolvers and a loading user code to initiate the actual queries. The options generally\nonly contain `include`s for nested relations (connection fields provide more complex query options).\nThe exception to this, is that we provide a default resolver for relations that can handle querying\nfor a relation if data was not pre-loaded by a parent field. This query used by this resolver is\nsimple, and described in detail below.\n\nWith this simple approach, we get an API that is easy to understand, but still provides a lot of\nvalue and functionality.\n\n## Example\n\nHere is a quick example of what an API using this plugin might look like. There is a more thorough\nbreakdown of what the methods and options used in the example below.\n\nIf you are looking for an example integrated with the\n[relay plugin](https://pothos-graphql.dev/plugins/relay), see the\n[Relay integration](#relay-integration) section below.\n\n```typescript\nbuilder.prismaObject('User', {\n  include: {\n    profile: true,\n  },\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    bio: t.string({\n      resolve: (user) => user.profile.bio,\n    }),\n    posts: t.relation('posts', {\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n    }),\n  }),\n});\n\nbuilder.prismaObject('Post', {\n  findUnique: (post) => ({ id: post.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.prismaField({\n      type: 'User',\n      resolve: async (query, root, args, ctx, info) =>\n        prisma.user.findUnique({\n          ...query,\n          rejectOnNotFound: true,\n          where: { id: ctx.userId },\n        }),\n    }),\n  }),\n});\n```\n\nGiven this schema, you would be able to resolve a query like the following with a single prisma\nquery (which will still result in a few optimized SQL queries).\n\n```graphql\nquery {\n  me {\n    email\n    posts {\n      title\n      author {\n        id\n      }\n    }\n  }\n}\n```\n\nA query like\n\n```graphql\nquery {\n  me {\n    email\n    posts {\n      title\n      author {\n        id\n      }\n    }\n    oldPosts: posts(oldestFirst: true) {\n      title\n      author {\n        id\n      }\n    }\n  }\n}\n```\n\nWill result in 2 calls to prisma, one to resolve everything except `oldPosts`, and a second to\nresolve everything inside `oldPosts`. Prisma can only resolve each relation once in a single query,\nso we need a separate to handle the second `posts` relation. This may seem slightly magical, but\nshould be predictable and hopefully easy to understand after reading the documentation below.\n\n## Pothos + Prisma without a plugin\n\nIf you just want learn about the plugin, feel free to skip this section, but understanding how to\nuse prisma without a plugin may be useful for evaluating if this plugin is a good fit for your use\ncase.\n\nUsing prisma without a plugin is relatively straight forward using the `builder.objectRef` method.\n\nThe easiest way to create types backed by prisma looks something like:\n\n```typescript\nimport { Post, PrismaClient, User } from '@prisma/client';\n\nconst db = new PrismaClient();\nconst UserObject = builder.objectRef<User>('User');\nconst PostObject = builder.objectRef<Post>('Post');\n\nUserObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.field({\n      type: [PostObject],\n      resolve: (user) =>\n        db.post.findMany({\n          where: { authorId: user.id },\n        }),\n    }),\n  }),\n});\n\nPostObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.field({\n      type: UserObject,\n      resolve: (post) =>\n        db.user.findUnique({ rejectOnNotFound: true, where: { id: post.authorId } }),\n    }),\n  }),\n});\n\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.field({\n      type: UserObject,\n      resolve: (root, args, ctx) =>\n        db.user.findUnique({ rejectOnNotFound: true, where: { id: ctx.userId } }),\n    }),\n  }),\n});\n```\n\nThis sets up User, and Post objects with a few fields, and a `me` query that returns the current\nuser. There are a few things to note in this setup:\n\n1. We split up the `builder.objectRef` and the `implement` calls, rather than calling\n   `builder.objectRef(...).implement(...)`. This prevents typescript from getting tripped up by the\n   circular references between posts and users.\n2. We use rejectOnNotFound with our `findUnique` calls because those fields are not nullable.\n   Without this option, prisma will return a null if the object is not found. An alternative is to\n   mark these fields as nullable.\n3. The refs to our object types are called `UserObject` and `PostObject`, this is because `User` and\n   `Post` are the names of the types imported from prisma. We could instead alias the types when we\n   import them so we can name the refs to our GraphQL types after the models.\n\nThis setup is fairly simple, but it is easy to see the n+1 issues we might run into. Prisma helps\nwith this by batching queries together, but there are also things we can do in our implementation to\nimprove things.\n\nOne thing we could do if we know we will usually be loading the author any time we load a post is to\nmake the author part of shape required for a post:\n\n```typescript\nconst UserObject = builder.objectRef<User>('User');\n// We add the author here in the objectRef\nconst PostObject = builder.objectRef<Post & { author: User }>('Post');\n\nUserObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.field({\n      type: [PostObject],\n      resolve: (user) =>\n        db.post.findMany({\n          // We now need to include the author when we query for posts\n          include: {\n            author: true,\n          },\n          where: { authorId: user.id },\n        }),\n    }),\n  }),\n});\n\nPostObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.field({\n      type: UserObject,\n      // Now we can just return the author from the post instead of querying for it\n      resolve: (post) => post.author,\n    }),\n  }),\n});\n```\n\nWe may not always want to query for the author though, so we could make the author optional and fall\nback to using a query if it was not provided by the parent resolver:\n\n```typescript\nconst PostObject = builder.objectRef<Post & { author?: User }>('Post');\n\nPostObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.field({\n      type: UserObject,\n      resolve: (post) =>\n        post.author ?? db.user.findUnique({ rejectOnNotFound: true, where: { id: post.authorId } }),\n    }),\n  }),\n});\n```\n\nWith this setup, a parent resolver has the option to include the author, but we have a fallback\nincase it does not.\n\nThere are other patterns like dataloaders than can be used to reduce n+1 issues, and make your graph\nmore efficient, but they are too complex to describe here.\n\n## Usage\n\n### Install\n\n```bash\nyarn add @pothos/plugin-prisma\n```\n\n### Setup\n\nThis plugin requires a little more setup than other plugins because it integrates with the prisma to\ngenerate some types that help the plugin better understand your prisma schema. Previous versions of\nthis plugin used to infer all required types from the prisma client itself, but this resulted in a\npoor dev experience because the complex types slowed down editors, and some more advanced use cases\ncould not be typed correctly.\n\n#### Add a the `pothos` generator to your prisma schema\n\n```\ngenerator pothos {\n  provider = \"prisma-pothos-types\"\n}\n```\n\nNow the types Pothos uses will be generated whenever you re-generate your prisma client. Run the\nfollowing command to re-generate the client and create the new types:\n\n```bash\nnpx prisma generate\n```\n\nadditional options:\n\n- `clientOutput`: Where the generated code will import the PrismaClient from. The default is the\n  full path of wherever the client is generated. If you are checking in the generated file, using\n  `@prisma/client` is a good option.\n- `output`: Where to write the generated types\n\nExample with more options:\n\n```\ngenerator pothos {\n  provider = \"prisma-pothos-types\"\n  clientOutput = \"@prisma/client\"\n  output = \"./pothos-types.ts\"\n}\n```\n\n#### Set up the builder\n\n```typescript\nimport SchemaBuilder from '@pothos/core';\nimport { PrismaClient } from '@prisma/client';\nimport PrismaPlugin from '@pothos/plugin-prisma';\n// This is the default location for the generator, but this can be customized as described above\n// Using a type only import will help avoid issues with undeclared exports in esm mode\nimport type PrismaTypes from '@pothos/plugin-prisma/generated';\n\nconst prisma = new PrismaClient({});\n\nconst builder = new SchemaBuilder<{\n  PrismaTypes: PrismaTypes;\n}>({\n  plugins: [PrismaPlugin],\n  prisma: {\n    client: prisma,\n  },\n});\n```\n\nIt is strongly recommended NOT to put your prisma client into `Context`. This will result in slower\ntype-checking and a laggy developer experience in VSCode. See\nhttps://github.com/microsoft/TypeScript/issues/45405 for more details.\n\n### Creating some types with `builder.prismaObject`\n\n`builder.prismaObject` takes 2 arguments:\n\n1. `name`: The name of the prisma model this new type represents\n2. `options`: options for the type being created, this is very similar to the options for any other\n   object type\n\n```typescript\nbuilder.prismaObject('User', {\n  // Optional name for the object, defaults to the name of the prisma model\n  name: 'PostAuthor',\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n  }),\n});\n\nbuilder.prismaObject('Post', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n  }),\n});\n```\n\nSo far, this is just creating some simple object types. They work just like any other object type in\nPothos. They main advantage of this is that we get the type information without using object refs,\nor needing imports from prisma client.\n\nThe `findUnique` option is described more below.\n\n### Adding prisma fields to non-prisma objects (including Query and Mutation)\n\nThere is a new `t.prismaField` method which can be used to define fields that resolve to your prisma\ntypes:\n\n```typescript\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.prismaField({\n      type: 'User',\n      resolve: async (query, root, args, ctx, info) =>\n        prisma.user.findUnique({\n          ...query,\n          rejectOnNotFound: true,\n          where: { id: ctx.userId },\n        }),\n    }),\n  }),\n});\n```\n\nThis method works just like th normal `t.field` method with a couple of differences:\n\n1. The `type` option must contain the name of the prisma model (eg. `User` or `[User]` for a list\n   field).\n2. The `resolve` function has a new first argument `query` which should be spread into query prisma\n   query. This will be used to load data for nested relationships.\n\nYou do not need to use this method, and the `builder.prismaObject` method returns an object ref than\ncan be used like any other object ref (with `t.field`), but using `t.prismaField` will allow you to\ntake advantage of more efficient queries.\n\nThe `query` object will contain an `include` object to pre-load data needed to resolve nested parts\nof the current query. This is based on fields defined with `t.relation` described below.\n\nIf there are no fields using `t.relation` in your query, everything is resolved exactly as it would\nbe without this plugin.\n\n### Adding relations\n\nYou can add fields for relations using the `t.relation` method:\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts', {\n      resolve: (query, user) =>\n        db.post.findMany({\n          ...query,\n          where: { authorId: user.id },\n        }),\n    }),\n  }),\n});\n\nbuilder.prismaObject('User', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.relation('author', {\n      resolve: (query, post) =>\n        db.user.findUnique({ ...query, rejectOnNotFound: true, where: { id: post.authorId } }),\n    }),\n  }),\n});\n```\n\n`t.relation` defines a field that can be pre-loaded by a parent resolver, and most of the time, the\n`resolve` function will NOT be called. This is VERY IMPORTANT to understand, because it is the\nbiggest place where you can introduce inconsistencies into your API with this plugin. The `resolve`\nfunction is used to load the relationship if parent resolver did not pre-load the data needed to\nresolve the field. This happens for a number of reasons:\n\n1. The parent object was not loaded through a field defined with `t.prismaField`, or `t.relation`\n2. The `query` object for the parent field was not spread into the query\n3. The graphql query requested multiple fields that depended on the same relationship (described\n   more below)\n\nThese are all okay, and expected situations. Graphql APIs are very flexible, and magically pushing\neverything into a single query is impossible for arbitrary queries. This is why we have a `resolve`\nfunction than can load the relation IF it was not already loaded by the parent.\n\nLike `t.prismaField`, the `resolve` function now as a new first argument that is a query that should\nbe spread into the query, and is used to load nested relationships.\n\n### Find Unique\n\nBecause the `resolve` function is only used as a fallback, it is harder to test, and if done\nincorrectly can introduce inconsistencies. While it shouldn't be too hard to get right, it might be\nbetter to avoid it entirely. To do this, we can let the Prisma plugin generate these resolve\nfunctions for you in a consistent and predictable way. We can do this by providing a findUnique\noption for our object type. Defining a `findUnique` that is not null, will make `resolve` optional.\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts'),\n  }),\n});\n\nbuilder.prismaObject('Post', {\n  findUnique: (post) => ({ id: post.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n```\n\nThis greatly simplifies our object types. In these cases, the fallback resolve functions will\nre-load the current object using the `findUnique` as the where clause, and then `include` the\nrelation for the current field. This can produce a slightly less efficient query than a manual\nimplementation because the parent object is re-loaded first, but it will batch multiple\nrelationships into one query, and the findUnique queries should be very fast.\n\nFor example, if a `User` was loaded without pre-loading, and both a `posts` and a `profile` relation\nwhere requested, the generated prisma call would be something like:\n\n```typescript\nprisma.user.findUnique({\n  rejectOnNotFound: true,\n  where: { id: user.id },\n  include: {\n    posts: true,\n    profile: true,\n  },\n});\n```\n\n### Filters, Sorting, and arguments\n\nSo far we have been describing very simple queries without any arguments, filtering, or sorting. For\n`t.prismaField` definitions, you can add arguments to your field like normal, and pass them into\nyour prisma query as needed. For `t.relation` the flow is slightly different because we need to make\nsure we are loading the right data if we are pre-loading data in a parent resolver. We do this by\nadding a `query` option to our field options.\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts', {\n      // We can define arguments like any other field\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      // Then we can generate our query conditions based on the arguments\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n    }),\n  }),\n});\n```\n\nThis query will be part of the `query` that gets passed into the first argument of `resolve`\nfunction for `t.relation` and `t.prismaField` based fields, and include things like `where`, `skip`,\n`take`, `orderBy`, etc. The `query` function will be passed the arguments for the field, and the\ncontext for the current request. Because it is used for pre-loading data, and solving n+1 issues, it\ncan not be passed the `parent` object because it may not be loaded yet.\n\nIf your field has a `resolve` method the generated `query` will be passed in as part of the first\narg to your resolve function\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts', {\n      // We can define arguments like any other field\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      // Then we can generate our query conditions based on the arguments\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n      // query here will contain the orderBy (and any other properties returned by the query method)\n      resolve: (query, post) => db.post.findMany({ ...query, where: { id: post.authorId } }),\n    }),\n  }),\n});\n```\n\nIt is VERY IMPORTANT to put all your filtering and sorting into the query method rather than your\nresolver because the resolver is only used as fallback, and any filtering that does not exist in the\nquery method will not be applied correctly. If you have a where in both your query and your\nresolver, you will need to ensure these are merged correctly. It is generally better NOT to use a\ncustom resolver.\n\n### Includes on types\n\nIn some cases, you may want to always pre-load certain relations. This can be helpful for defining\nfields directly on type where the underlying data may come from a related table.\n\n```typescript\nbuilder.prismaObject('User', {\n  // This will always include the profile when a user object is loaded.  Deeply nested relations can\n  // also be included this way.\n  include: {\n    profile: true,\n  },\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    bio: t.string({\n      // The profile relation will always be loaded, and user will now be typed to include the\n      // profile field so you can return the bio from the nested profile relation.\n      resolve: (user) => user.profile.bio,\n    }),\n  }),\n});\n```\n\n### relationCount\n\nPrisma supports querying for\n[relation counts](https://www.prisma.io/docs/concepts/components/prisma-client/aggregation-grouping-summarizing#count-relations)\nwhich allow including counts for relations along side other `includes`. This does not currently\nsupport any filters on the counts, but can give a total count for a relation.\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    postCount: t.relationCount('posts'),\n  }),\n});\n```\n\n## Relay integration\n\nThis plugin has extensive integration with the\n[relay plugin](https://pothos-graphql.dev/plugins/relay), which makes creating nodes and connections\nvery easy.\n\n### Example\n\nThe following example is similar to the one above with a few changes:\n\n- the `User` and `Post` objects are now relay nodes\n- the `posts` field on the `User` type is now a relay connection using cursor based pagination\n- there is a new `users` query that is also a relay connection\n\nEverything in this schema is still queryable via a single prisma query. The relay connections\nhandles pre-loading like all the other fields.\n\n```typescript\nbuilder.prismaNode('User', {\n  findUnique: (id) => ({ id }),\n  id: { resolve: (user) => user.id },\n  fields: (t) => ({\n    email: t.exposeString('email'),\n    posts: t.relatedConnection('posts', {\n      cursor: 'id',\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n    }),\n  }),\n});\n\nbuilder.prismaNode('Post', {\n  findUnique: (id) => ({ id }),\n  id: { resolve: (post) => post.id },\n  fields: (t) => ({\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.prismaField({\n      type: 'User',\n      resolve: async (query, root, args, ctx, info) =>\n        prisma.user.findUnique({\n          ...query,\n          rejectOnNotFound: true,\n          where: { id: ctx.userId },\n        }),\n    }),\n    posts: t.prismaConnection({\n      type: 'Post',\n      cursor: 'id',\n      resolve: (query) => prisma.post.findMany(query),\n    }),\n  }),\n});\n```\n\n### `prismaNode`\n\nThe `prismaNode` method works just like the `prismaObject` method with a couple of small\ndifferences:\n\n- the `findUnique` function now only receives an id. This is to support relays ability to load nodes\n  by id.\n- there is a new `id` option that mirrors the `id` option from `node` method of the relay plugin,\n  and must contain a resolve function that returns the id from an instance of the node.\n\n```typescript\nbuilder.prismaNode('Post', {\n  // This is used to load the node by id\n  findUnique: (id) => ({ id }),\n  // This is used to get the id from a node\n  id: { resolve: (post) => post.id },\n  // fields work just like they do for builder.prismaObject\n  fields: (t) => ({\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n```\n\n### `prismaConnection`\n\nThe `prismaConnection` method on a field builder can be used to create a relay `connection` field\nthat also pre-loads all the data nested inside that connection.\n\n```typescript\nbuilder.queryType({\n  fields: (t) => ({\n    posts: t.prismaConnection(\n      {\n        type: 'Post',\n        cursor: 'id',\n        resolve: (query, parent, args, context, info) => prisma.post.findMany({ ...query }),\n      }),\n      {}, // optional options for the Connection type\n      {}, // optional options for the Edge type),\n    ),\n  }),\n});\n```\n\n#### options\n\n- `type`: the name of the prisma model being connected to\n- `cursor`: a `@unique` column of the model being connected to. This is used as the `cursor` option\n  passed to prisma.\n- `defaultSize`: (default: 20) The default page size to use if `first` and `last` are not provided.\n- `maxSize`: (default: 100) The maximum number of nodes returned for a connection.\n- `resolve`: Like the resolver for `prismaField`, the first argument is a `query` object that should\n  be spread into your prisma query. The `resolve` function should return an array of nodes for the\n  connection. The `query` will contain the correct `take`, `skip`, and `cursor` options based on the\n  connection arguments (`before`, `after`, `first`, `last`), along with `include` options for nested\n  selections.\n\nThe created connection queries currently support the following combinations of connection arguments:\n\n- `first`, `last`, or `before`\n- `first` and `before`\n- `last` and `after`\n\nQueries for other combinations are not as useful, and generally requiring loading all records\nbetween 2 cursors, or between a cursor and the end of the set. Generating query options for these\ncases is more complex and likely very inefficient, so they will currently throw an Error indicating\nthe argument combinations are not supported.\n\n### `relatedConnection`\n\nThe `relatedConnection` method can be used to create a relay `connection` field based on a relation\nof the current model.\n\n```typescript\nbuilder.prismaNode('User', {\n  findUnique: (id) => ({ id }),\n  id: { resolve: (user) => user.id },\n  fields: (t) => ({\n    // Connections can be very simple to define\n    simplePosts: t.relatedConnection('posts', {\n      cursor: 'id',\n    }),\n    // Or they can include custom arguments, and other options\n    posts: t.relatedConnection(\n      'posts',\n      {\n        cursor: 'id',\n        args: {\n          oldestFirst: t.arg.boolean(),\n        },\n        query: (args, context) => ({\n          orderBy: {\n            createdAt: args.oldestFirst ? 'asc' : 'desc',\n          },\n        }),\n      },\n      {}, // optional options for the Connection type\n      {}, // optional options for the Edge type),\n    ),\n  }),\n});\n```\n\n#### options\n\n- `cursor`: a `@unique` column of the model being connected to. This is used as the `cursor` option\n  passed to prisma.\n- `defaultSize`: (default: 20) The default page size to use if `first` and `last` are not provided.\n- `maxSize`: (default: 100) The maximum number of nodes returned for a connection.\n- `resolve`: (optional) Used as a fallback when a connection is not pre-loaded. It is optional, and\n  generally should NOT be defined manually. If used it works like a combination of the `resolve`\n  method of `relation` and `prismaConnection`. The default will use the `findUnique` of the current\n  model, with an `include` for the current relation. It is also batched together with other\n  relationships to improve query efficiency.\n- `totalCount`: when set to true, this will add a `totalCount` field to the connection object. see\n  `relationCount` above for more details.\n"
+  "readme": "# Prisma Plugin for Pothos\n\nThis plugin provides tighter integration with prisma, making it easier to define prisma based object\ntypes, and helps solve n+1 queries for relations. It also has integrations for the relay plugin to\nmake defining nodes and connections easy and efficient.\n\n## Disclaimers\n\nThis plugin is experimental, and will have some breaking changes in the future. DO NOT USE this\nplugin unless you are willing to deal with breaking changes in upcoming versions. This plugin may\nintroduce BREAKING changes in minor versions until it's major version has been increased above 0.\n\nThis plugin is NOT required to build graphs backed by prisma models, and I would not recommend using\nit unless you have a solid understanding of how it will construct queries.\n\nThis plugin will allow common queries to be resolved through a single prisma query (prisma may still\nturn this into multiple SQL queries), and provides reasonable, predictable and safe fallbacks for\nmore complex queries and edge cases. That being said, graphql APIs are complex, and it is important\nto understand the queries your API is capable of executing.\n\nThe way this plugin resolves queries is designed to be efficient, while still being predictable and\neasy to understand. Tools that try to automatically generate queries are often hard to understand\nand reason about, so this plugin tries to make things as clear as possible by providing query\noptions to resolvers and a loading user code to initiate the actual queries. The options generally\nonly contain `include`s for nested relations (connection fields provide more complex query options).\nThe exception to this, is that we provide a default resolver for relations that can handle querying\nfor a relation if data was not pre-loaded by a parent field. This query used by this resolver is\nsimple, and described in detail below.\n\nWith this simple approach, we get an API that is easy to understand, but still provides a lot of\nvalue and functionality.\n\n## Example\n\nHere is a quick example of what an API using this plugin might look like. There is a more thorough\nbreakdown of what the methods and options used in the example below.\n\nIf you are looking for an example integrated with the\n[relay plugin](https://pothos-graphql.dev/docs/plugins/relay), see the\n[Relay integration](#relay-integration) section below.\n\n```typescript\nbuilder.prismaObject('User', {\n  include: {\n    profile: true,\n  },\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    bio: t.string({\n      resolve: (user) => user.profile.bio,\n    }),\n    posts: t.relation('posts', {\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n    }),\n  }),\n});\n\nbuilder.prismaObject('Post', {\n  findUnique: (post) => ({ id: post.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.prismaField({\n      type: 'User',\n      resolve: async (query, root, args, ctx, info) =>\n        prisma.user.findUnique({\n          ...query,\n          rejectOnNotFound: true,\n          where: { id: ctx.userId },\n        }),\n    }),\n  }),\n});\n```\n\nGiven this schema, you would be able to resolve a query like the following with a single prisma\nquery (which will still result in a few optimized SQL queries).\n\n```graphql\nquery {\n  me {\n    email\n    posts {\n      title\n      author {\n        id\n      }\n    }\n  }\n}\n```\n\nA query like\n\n```graphql\nquery {\n  me {\n    email\n    posts {\n      title\n      author {\n        id\n      }\n    }\n    oldPosts: posts(oldestFirst: true) {\n      title\n      author {\n        id\n      }\n    }\n  }\n}\n```\n\nWill result in 2 calls to prisma, one to resolve everything except `oldPosts`, and a second to\nresolve everything inside `oldPosts`. Prisma can only resolve each relation once in a single query,\nso we need a separate to handle the second `posts` relation. This may seem slightly magical, but\nshould be predictable and hopefully easy to understand after reading the documentation below.\n\n## Pothos + Prisma without a plugin\n\nIf you just want learn about the plugin, feel free to skip this section, but understanding how to\nuse prisma without a plugin may be useful for evaluating if this plugin is a good fit for your use\ncase.\n\nUsing prisma without a plugin is relatively straight forward using the `builder.objectRef` method.\n\nThe easiest way to create types backed by prisma looks something like:\n\n```typescript\nimport { Post, PrismaClient, User } from '@prisma/client';\n\nconst db = new PrismaClient();\nconst UserObject = builder.objectRef<User>('User');\nconst PostObject = builder.objectRef<Post>('Post');\n\nUserObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.field({\n      type: [PostObject],\n      resolve: (user) =>\n        db.post.findMany({\n          where: { authorId: user.id },\n        }),\n    }),\n  }),\n});\n\nPostObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.field({\n      type: UserObject,\n      resolve: (post) =>\n        db.user.findUnique({ rejectOnNotFound: true, where: { id: post.authorId } }),\n    }),\n  }),\n});\n\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.field({\n      type: UserObject,\n      resolve: (root, args, ctx) =>\n        db.user.findUnique({ rejectOnNotFound: true, where: { id: ctx.userId } }),\n    }),\n  }),\n});\n```\n\nThis sets up User, and Post objects with a few fields, and a `me` query that returns the current\nuser. There are a few things to note in this setup:\n\n1. We split up the `builder.objectRef` and the `implement` calls, rather than calling\n   `builder.objectRef(...).implement(...)`. This prevents typescript from getting tripped up by the\n   circular references between posts and users.\n2. We use rejectOnNotFound with our `findUnique` calls because those fields are not nullable.\n   Without this option, prisma will return a null if the object is not found. An alternative is to\n   mark these fields as nullable.\n3. The refs to our object types are called `UserObject` and `PostObject`, this is because `User` and\n   `Post` are the names of the types imported from prisma. We could instead alias the types when we\n   import them so we can name the refs to our GraphQL types after the models.\n\nThis setup is fairly simple, but it is easy to see the n+1 issues we might run into. Prisma helps\nwith this by batching queries together, but there are also things we can do in our implementation to\nimprove things.\n\nOne thing we could do if we know we will usually be loading the author any time we load a post is to\nmake the author part of shape required for a post:\n\n```typescript\nconst UserObject = builder.objectRef<User>('User');\n// We add the author here in the objectRef\nconst PostObject = builder.objectRef<Post & { author: User }>('Post');\n\nUserObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.field({\n      type: [PostObject],\n      resolve: (user) =>\n        db.post.findMany({\n          // We now need to include the author when we query for posts\n          include: {\n            author: true,\n          },\n          where: { authorId: user.id },\n        }),\n    }),\n  }),\n});\n\nPostObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.field({\n      type: UserObject,\n      // Now we can just return the author from the post instead of querying for it\n      resolve: (post) => post.author,\n    }),\n  }),\n});\n```\n\nWe may not always want to query for the author though, so we could make the author optional and fall\nback to using a query if it was not provided by the parent resolver:\n\n```typescript\nconst PostObject = builder.objectRef<Post & { author?: User }>('Post');\n\nPostObject.implement({\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.field({\n      type: UserObject,\n      resolve: (post) =>\n        post.author ?? db.user.findUnique({ rejectOnNotFound: true, where: { id: post.authorId } }),\n    }),\n  }),\n});\n```\n\nWith this setup, a parent resolver has the option to include the author, but we have a fallback\nincase it does not.\n\nThere are other patterns like dataloaders than can be used to reduce n+1 issues, and make your graph\nmore efficient, but they are too complex to describe here.\n\n## Usage\n\n### Install\n\n```bash\nyarn add @pothos/plugin-prisma\n```\n\n### Setup\n\nThis plugin requires a little more setup than other plugins because it integrates with the prisma to\ngenerate some types that help the plugin better understand your prisma schema. Previous versions of\nthis plugin used to infer all required types from the prisma client itself, but this resulted in a\npoor dev experience because the complex types slowed down editors, and some more advanced use cases\ncould not be typed correctly.\n\n#### Add a the `pothos` generator to your prisma schema\n\n```\ngenerator pothos {\n  provider = \"prisma-pothos-types\"\n}\n```\n\nNow the types Pothos uses will be generated whenever you re-generate your prisma client. Run the\nfollowing command to re-generate the client and create the new types:\n\n```bash\nnpx prisma generate\n```\n\nadditional options:\n\n- `clientOutput`: Where the generated code will import the PrismaClient from. The default is the\n  full path of wherever the client is generated. If you are checking in the generated file, using\n  `@prisma/client` is a good option.\n- `output`: Where to write the generated types\n\nExample with more options:\n\n```\ngenerator pothos {\n  provider = \"prisma-pothos-types\"\n  clientOutput = \"@prisma/client\"\n  output = \"./pothos-types.ts\"\n}\n```\n\n#### Set up the builder\n\n```typescript\nimport SchemaBuilder from '@pothos/core';\nimport { PrismaClient } from '@prisma/client';\nimport PrismaPlugin from '@pothos/plugin-prisma';\n// This is the default location for the generator, but this can be customized as described above\n// Using a type only import will help avoid issues with undeclared exports in esm mode\nimport type PrismaTypes from '@pothos/plugin-prisma/generated';\n\nconst prisma = new PrismaClient({});\n\nconst builder = new SchemaBuilder<{\n  PrismaTypes: PrismaTypes;\n}>({\n  plugins: [PrismaPlugin],\n  prisma: {\n    client: prisma,\n  },\n});\n```\n\nIt is strongly recommended NOT to put your prisma client into `Context`. This will result in slower\ntype-checking and a laggy developer experience in VSCode. See\nhttps://github.com/microsoft/TypeScript/issues/45405 for more details.\n\n### Creating some types with `builder.prismaObject`\n\n`builder.prismaObject` takes 2 arguments:\n\n1. `name`: The name of the prisma model this new type represents\n2. `options`: options for the type being created, this is very similar to the options for any other\n   object type\n\n```typescript\nbuilder.prismaObject('User', {\n  // Optional name for the object, defaults to the name of the prisma model\n  name: 'PostAuthor',\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n  }),\n});\n\nbuilder.prismaObject('Post', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n  }),\n});\n```\n\nSo far, this is just creating some simple object types. They work just like any other object type in\nPothos. They main advantage of this is that we get the type information without using object refs,\nor needing imports from prisma client.\n\nThe `findUnique` option is described more below.\n\n### Adding prisma fields to non-prisma objects (including Query and Mutation)\n\nThere is a new `t.prismaField` method which can be used to define fields that resolve to your prisma\ntypes:\n\n```typescript\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.prismaField({\n      type: 'User',\n      resolve: async (query, root, args, ctx, info) =>\n        prisma.user.findUnique({\n          ...query,\n          rejectOnNotFound: true,\n          where: { id: ctx.userId },\n        }),\n    }),\n  }),\n});\n```\n\nThis method works just like th normal `t.field` method with a couple of differences:\n\n1. The `type` option must contain the name of the prisma model (eg. `User` or `[User]` for a list\n   field).\n2. The `resolve` function has a new first argument `query` which should be spread into query prisma\n   query. This will be used to load data for nested relationships.\n\nYou do not need to use this method, and the `builder.prismaObject` method returns an object ref than\ncan be used like any other object ref (with `t.field`), but using `t.prismaField` will allow you to\ntake advantage of more efficient queries.\n\nThe `query` object will contain an `include` object to pre-load data needed to resolve nested parts\nof the current query. This is based on fields defined with `t.relation` described below.\n\nIf there are no fields using `t.relation` in your query, everything is resolved exactly as it would\nbe without this plugin.\n\n### Adding relations\n\nYou can add fields for relations using the `t.relation` method:\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts', {\n      resolve: (query, user) =>\n        db.post.findMany({\n          ...query,\n          where: { authorId: user.id },\n        }),\n    }),\n  }),\n});\n\nbuilder.prismaObject('User', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.relation('author', {\n      resolve: (query, post) =>\n        db.user.findUnique({ ...query, rejectOnNotFound: true, where: { id: post.authorId } }),\n    }),\n  }),\n});\n```\n\n`t.relation` defines a field that can be pre-loaded by a parent resolver, and most of the time, the\n`resolve` function will NOT be called. This is VERY IMPORTANT to understand, because it is the\nbiggest place where you can introduce inconsistencies into your API with this plugin. The `resolve`\nfunction is used to load the relationship if parent resolver did not pre-load the data needed to\nresolve the field. This happens for a number of reasons:\n\n1. The parent object was not loaded through a field defined with `t.prismaField`, or `t.relation`\n2. The `query` object for the parent field was not spread into the query\n3. The graphql query requested multiple fields that depended on the same relationship (described\n   more below)\n\nThese are all okay, and expected situations. Graphql APIs are very flexible, and magically pushing\neverything into a single query is impossible for arbitrary queries. This is why we have a `resolve`\nfunction than can load the relation IF it was not already loaded by the parent.\n\nLike `t.prismaField`, the `resolve` function now as a new first argument that is a query that should\nbe spread into the query, and is used to load nested relationships.\n\n### Find Unique\n\nBecause the `resolve` function is only used as a fallback, it is harder to test, and if done\nincorrectly can introduce inconsistencies. While it shouldn't be too hard to get right, it might be\nbetter to avoid it entirely. To do this, we can let the Prisma plugin generate these resolve\nfunctions for you in a consistent and predictable way. We can do this by providing a findUnique\noption for our object type. Defining a `findUnique` that is not null, will make `resolve` optional.\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts'),\n  }),\n});\n\nbuilder.prismaObject('Post', {\n  findUnique: (post) => ({ id: post.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n```\n\nThis greatly simplifies our object types. In these cases, the fallback resolve functions will\nre-load the current object using the `findUnique` as the where clause, and then `include` the\nrelation for the current field. This can produce a slightly less efficient query than a manual\nimplementation because the parent object is re-loaded first, but it will batch multiple\nrelationships into one query, and the findUnique queries should be very fast.\n\nFor example, if a `User` was loaded without pre-loading, and both a `posts` and a `profile` relation\nwhere requested, the generated prisma call would be something like:\n\n```typescript\nprisma.user.findUnique({\n  rejectOnNotFound: true,\n  where: { id: user.id },\n  include: {\n    posts: true,\n    profile: true,\n  },\n});\n```\n\n### Filters, Sorting, and arguments\n\nSo far we have been describing very simple queries without any arguments, filtering, or sorting. For\n`t.prismaField` definitions, you can add arguments to your field like normal, and pass them into\nyour prisma query as needed. For `t.relation` the flow is slightly different because we need to make\nsure we are loading the right data if we are pre-loading data in a parent resolver. We do this by\nadding a `query` option to our field options.\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts', {\n      // We can define arguments like any other field\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      // Then we can generate our query conditions based on the arguments\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n    }),\n  }),\n});\n```\n\nThis query will be part of the `query` that gets passed into the first argument of `resolve`\nfunction for `t.relation` and `t.prismaField` based fields, and include things like `where`, `skip`,\n`take`, `orderBy`, etc. The `query` function will be passed the arguments for the field, and the\ncontext for the current request. Because it is used for pre-loading data, and solving n+1 issues, it\ncan not be passed the `parent` object because it may not be loaded yet.\n\nIf your field has a `resolve` method the generated `query` will be passed in as part of the first\narg to your resolve function\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: null,\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    posts: t.relation('posts', {\n      // We can define arguments like any other field\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      // Then we can generate our query conditions based on the arguments\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n      // query here will contain the orderBy (and any other properties returned by the query method)\n      resolve: (query, post) => db.post.findMany({ ...query, where: { id: post.authorId } }),\n    }),\n  }),\n});\n```\n\nIt is VERY IMPORTANT to put all your filtering and sorting into the query method rather than your\nresolver because the resolver is only used as fallback, and any filtering that does not exist in the\nquery method will not be applied correctly. If you have a where in both your query and your\nresolver, you will need to ensure these are merged correctly. It is generally better NOT to use a\ncustom resolver.\n\n### Includes on types\n\nIn some cases, you may want to always pre-load certain relations. This can be helpful for defining\nfields directly on type where the underlying data may come from a related table.\n\n```typescript\nbuilder.prismaObject('User', {\n  // This will always include the profile when a user object is loaded.  Deeply nested relations can\n  // also be included this way.\n  include: {\n    profile: true,\n  },\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    email: t.exposeString('email'),\n    bio: t.string({\n      // The profile relation will always be loaded, and user will now be typed to include the\n      // profile field so you can return the bio from the nested profile relation.\n      resolve: (user) => user.profile.bio,\n    }),\n  }),\n});\n```\n\n### relationCount\n\nPrisma supports querying for\n[relation counts](https://www.prisma.io/docs/concepts/components/prisma-client/aggregation-grouping-summarizing#count-relations)\nwhich allow including counts for relations along side other `includes`. This does not currently\nsupport any filters on the counts, but can give a total count for a relation.\n\n```typescript\nbuilder.prismaObject('User', {\n  findUnique: (user) => ({ id: user.id }),\n  fields: (t) => ({\n    id: t.exposeID('id'),\n    postCount: t.relationCount('posts'),\n  }),\n});\n```\n\n## Relay integration\n\nThis plugin has extensive integration with the\n[relay plugin](https://pothos-graphql.dev/docs/plugins/relay), which makes creating nodes and\nconnections very easy.\n\n### Example\n\nThe following example is similar to the one above with a few changes:\n\n- the `User` and `Post` objects are now relay nodes\n- the `posts` field on the `User` type is now a relay connection using cursor based pagination\n- there is a new `users` query that is also a relay connection\n\nEverything in this schema is still queryable via a single prisma query. The relay connections\nhandles pre-loading like all the other fields.\n\n```typescript\nbuilder.prismaNode('User', {\n  findUnique: (id) => ({ id }),\n  id: { resolve: (user) => user.id },\n  fields: (t) => ({\n    email: t.exposeString('email'),\n    posts: t.relatedConnection('posts', {\n      cursor: 'id',\n      args: {\n        oldestFirst: t.arg.boolean(),\n      },\n      query: (args, context) => ({\n        orderBy: {\n          createdAt: args.oldestFirst ? 'asc' : 'desc',\n        },\n      }),\n    }),\n  }),\n});\n\nbuilder.prismaNode('Post', {\n  findUnique: (id) => ({ id }),\n  id: { resolve: (post) => post.id },\n  fields: (t) => ({\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n\nbuilder.queryType({\n  fields: (t) => ({\n    me: t.prismaField({\n      type: 'User',\n      resolve: async (query, root, args, ctx, info) =>\n        prisma.user.findUnique({\n          ...query,\n          rejectOnNotFound: true,\n          where: { id: ctx.userId },\n        }),\n    }),\n    posts: t.prismaConnection({\n      type: 'Post',\n      cursor: 'id',\n      resolve: (query) => prisma.post.findMany(query),\n    }),\n  }),\n});\n```\n\n### `prismaNode`\n\nThe `prismaNode` method works just like the `prismaObject` method with a couple of small\ndifferences:\n\n- the `findUnique` function now only receives an id. This is to support relays ability to load nodes\n  by id.\n- there is a new `id` option that mirrors the `id` option from `node` method of the relay plugin,\n  and must contain a resolve function that returns the id from an instance of the node.\n\n```typescript\nbuilder.prismaNode('Post', {\n  // This is used to load the node by id\n  findUnique: (id) => ({ id }),\n  // This is used to get the id from a node\n  id: { resolve: (post) => post.id },\n  // fields work just like they do for builder.prismaObject\n  fields: (t) => ({\n    title: t.exposeString('title'),\n    author: t.relation('author'),\n  }),\n});\n```\n\n### `prismaConnection`\n\nThe `prismaConnection` method on a field builder can be used to create a relay `connection` field\nthat also pre-loads all the data nested inside that connection.\n\n```typescript\nbuilder.queryType({\n  fields: (t) => ({\n    posts: t.prismaConnection(\n      {\n        type: 'Post',\n        cursor: 'id',\n        resolve: (query, parent, args, context, info) => prisma.post.findMany({ ...query }),\n      }),\n      {}, // optional options for the Connection type\n      {}, // optional options for the Edge type),\n    ),\n  }),\n});\n```\n\n#### options\n\n- `type`: the name of the prisma model being connected to\n- `cursor`: a `@unique` column of the model being connected to. This is used as the `cursor` option\n  passed to prisma.\n- `defaultSize`: (default: 20) The default page size to use if `first` and `last` are not provided.\n- `maxSize`: (default: 100) The maximum number of nodes returned for a connection.\n- `resolve`: Like the resolver for `prismaField`, the first argument is a `query` object that should\n  be spread into your prisma query. The `resolve` function should return an array of nodes for the\n  connection. The `query` will contain the correct `take`, `skip`, and `cursor` options based on the\n  connection arguments (`before`, `after`, `first`, `last`), along with `include` options for nested\n  selections.\n\nThe created connection queries currently support the following combinations of connection arguments:\n\n- `first`, `last`, or `before`\n- `first` and `before`\n- `last` and `after`\n\nQueries for other combinations are not as useful, and generally requiring loading all records\nbetween 2 cursors, or between a cursor and the end of the set. Generating query options for these\ncases is more complex and likely very inefficient, so they will currently throw an Error indicating\nthe argument combinations are not supported.\n\n### `relatedConnection`\n\nThe `relatedConnection` method can be used to create a relay `connection` field based on a relation\nof the current model.\n\n```typescript\nbuilder.prismaNode('User', {\n  findUnique: (id) => ({ id }),\n  id: { resolve: (user) => user.id },\n  fields: (t) => ({\n    // Connections can be very simple to define\n    simplePosts: t.relatedConnection('posts', {\n      cursor: 'id',\n    }),\n    // Or they can include custom arguments, and other options\n    posts: t.relatedConnection(\n      'posts',\n      {\n        cursor: 'id',\n        args: {\n          oldestFirst: t.arg.boolean(),\n        },\n        query: (args, context) => ({\n          orderBy: {\n            createdAt: args.oldestFirst ? 'asc' : 'desc',\n          },\n        }),\n      },\n      {}, // optional options for the Connection type\n      {}, // optional options for the Edge type),\n    ),\n  }),\n});\n```\n\n#### options\n\n- `cursor`: a `@unique` column of the model being connected to. This is used as the `cursor` option\n  passed to prisma.\n- `defaultSize`: (default: 20) The default page size to use if `first` and `last` are not provided.\n- `maxSize`: (default: 100) The maximum number of nodes returned for a connection.\n- `resolve`: (optional) Used as a fallback when a connection is not pre-loaded. It is optional, and\n  generally should NOT be defined manually. If used it works like a combination of the `resolve`\n  method of `relation` and `prismaConnection`. The default will use the `findUnique` of the current\n  model, with an `include` for the current relation. It is also batched together with other\n  relationships to improve query efficiency.\n- `totalCount`: when set to true, this will add a `totalCount` field to the connection object. see\n  `relationCount` above for more details.\n"
 }

package/src/field-builder.ts

@@ -6,7 +6,6 @@ import {
   ObjectRef,
   RootFieldBuilder,
   SchemaTypes,
-  TypeParam,
 } from '@pothos/core';
 import { resolvePrismaCursorConnection } from './cursors';
 import { getRefFromModel } from './refs';
@@ -22,9 +21,12 @@ const fieldBuilderProto = RootFieldBuilder.prototype as PothosSchemaTypes.RootFi
 >;
 
 fieldBuilderProto.prismaField = function prismaField({ type, resolve, ...options }) {
-  const model: string = Array.isArray(type) ? type[0] : type;
-  const typeRef = getRefFromModel(model, this.builder);
-  const typeParam: TypeParam<SchemaTypes> = Array.isArray(type) ? [typeRef] : typeRef;
+  const modelOrRef = Array.isArray(type) ? type[0] : type;
+  const typeRef =
+    typeof modelOrRef === 'string'
+      ? getRefFromModel(modelOrRef, this.builder)
+      : (modelOrRef as ObjectRef<unknown>);
+  const typeParam = Array.isArray(type) ? ([typeRef] as [ObjectRef<unknown>]) : typeRef;
 
   return this.field({
     ...options,
@@ -66,7 +68,7 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
   connectionOptions: {},
   edgeOptions: {},
 ) {
-  const ref = getRefFromModel(type, this.builder);
+  const ref = typeof type === 'string' ? getRefFromModel(type, this.builder) : type;
   let typeName: string | undefined;
 
   const fieldRef = (

package/src/generator.ts

@@ -45,7 +45,14 @@ generatorHandler({
         [],
         model.name,
         undefined,
+
         ts.factory.createTypeLiteralNode([
+          ts.factory.createPropertySignature(
+            [],
+            'Name',
+            undefined,
+            ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(model.name)),
+          ),
           ts.factory.createPropertySignature(
             [],
             'Shape',

package/src/global-types.ts

@@ -7,13 +7,13 @@ import {
   InputFieldMap,
   InterfaceParam,
   NormalizeArgs,
-  ObjectRef,
   OutputType,
   PluginName,
   SchemaTypes,
   ShapeFromTypeParam,
 } from '@pothos/core';
 import PrismaNodeRef from './node-ref';
+import { prismaModelKey, PrismaObjectRef } from './object-ref';
 import {
   PrismaConnectionFieldOptions,
   PrismaFieldOptions,
@@ -59,7 +59,7 @@ declare global {
       >(
         name: Name,
         options: PrismaObjectTypeOptions<Types, Model, Interfaces, FindUnique, Include, Shape>,
-      ) => ObjectRef<Shape>;
+      ) => PrismaObjectRef<Model, Shape>;
 
       prismaNode: 'relay' extends PluginName
         ? <
@@ -71,7 +71,7 @@ declare global {
           >(
             name: Name,
             options: PrismaNodeOptions<Types, Model, Interfaces, Include, Shape>,
-          ) => PrismaNodeRef<Shape>
+          ) => PrismaNodeRef<Model, Shape>
         : '@pothos/plugin-relay is required to use this method';
     }
 
@@ -82,15 +82,23 @@ declare global {
     > {
       prismaField: <
         Args extends InputFieldMap,
-        TypeParam extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],
+        TypeParam extends
+          | PrismaObjectRef<PrismaModelTypes>
+          | keyof Types['PrismaTypes']
+          | [keyof Types['PrismaTypes']]
+          | [PrismaObjectRef<PrismaModelTypes>],
         Nullable extends FieldNullability<Type>,
         ResolveReturnShape,
-        Type extends TypeParam extends [keyof Types['PrismaTypes']]
+        Type extends TypeParam extends [unknown]
           ? [ObjectRef<Model['Shape']>]
           : ObjectRef<Model['Shape']>,
         Model extends PrismaModelTypes = PrismaModelTypes &
           (TypeParam extends [keyof Types['PrismaTypes']]
             ? Types['PrismaTypes'][TypeParam[0]]
+            : TypeParam extends [PrismaObjectRef<PrismaModelTypes>]
+            ? TypeParam[0][typeof prismaModelKey]
+            : TypeParam extends PrismaObjectRef<PrismaModelTypes>
+            ? TypeParam[typeof prismaModelKey]
             : TypeParam extends keyof Types['PrismaTypes']
             ? Types['PrismaTypes'][TypeParam]
             : never),
@@ -110,11 +118,13 @@ declare global {
 
       prismaConnection: 'relay' extends PluginName
         ? <
-            Type extends keyof Types['PrismaTypes'],
+            Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
             Nullable extends boolean,
             ResolveReturnShape,
             Args extends InputFieldMap = {},
-            Model extends PrismaModelTypes = PrismaModelTypes & Types['PrismaTypes'][Type],
+            Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer T>
+              ? T
+              : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
           >(
             ...args: NormalizeArgs<
               [

package/src/model-loader.ts

@@ -66,6 +66,20 @@ export class ModelLoader {
     return (result._count as Record<string, number>)[relation];
   }
 
+  async loadSelf(include: unknown, context: {}) {
+    for (const entry of this.staged) {
+      const merged = mergeIncludes(entry.include, include as Record<string, unknown>);
+
+      if (merged) {
+        entry.include = merged as Record<string, unknown>;
+
+        return entry.promise;
+      }
+    }
+
+    return this.initLoad(null, include, context);
+  }
+
   async loadRelation(relation: string, include: unknown, context: {}) {
     let promise;
     for (const entry of this.staged) {
@@ -96,18 +110,21 @@ export class ModelLoader {
     return result[relation];
   }
 
-  async initLoad(relation: string, includeArg: unknown, context: {}, count = false) {
-    const include: Record<string, unknown> = count
-      ? {
-          _count: {
-            select: {
-              [relation]: true,
-            },
-          },
-        }
-      : {
-          [relation]: includeArg,
-        };
+  async initLoad(relation: string | null, includeArg: unknown, context: {}, count = false) {
+    const include: Record<string, unknown> =
+      (relation &&
+        (count
+          ? {
+              _count: {
+                select: {
+                  [relation]: true,
+                },
+              },
+            }
+          : {
+              [relation]: includeArg,
+            })) ||
+      {};
 
     const promise = new Promise<Record<string, unknown>>((resolve, reject) => {
       setTimeout(() => {
@@ -117,7 +134,7 @@ export class ModelLoader {
           this.delegate.findUnique({
             rejectOnNotFound: true,
             where: { ...(this.findUnique(this.model, context) as {}) },
-            include,
+            include: Object.keys(include).length > 0 ? include : undefined,
           } as never) as Promise<Record<string, unknown>>,
         );
       }, 0);

package/src/node-ref.ts

@@ -1,7 +1,12 @@
-import { abstractReturnShapeKey, brandWithType, ObjectRef, typeBrandKey } from '@pothos/core';
+import { abstractReturnShapeKey, brandWithType, typeBrandKey } from '@pothos/core';
+import { PrismaObjectRef } from './object-ref';
 import { WithBrand } from './types';
+import { PrismaModelTypes } from '.';
 
-export default class PrismaNodeRef<T> extends ObjectRef<T, T> {
+export default class PrismaNodeRef<Model extends PrismaModelTypes, T> extends PrismaObjectRef<
+  Model,
+  T
+> {
   [abstractReturnShapeKey]: WithBrand<T>;
 
   addBrand<V extends T | T[]>(

package/src/object-ref.ts

@@ -0,0 +1,8 @@
+import { ObjectRef } from '@pothos/core';
+import { PrismaModelTypes } from '.';
+
+export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
+
+export class PrismaObjectRef<Model extends PrismaModelTypes, T = {}> extends ObjectRef<T> {
+  [prismaModelKey]: Model;
+}

package/src/prisma-field-builder.ts

@@ -13,6 +13,7 @@ import {
 import { prismaCursorConnectionQuery, wrapConnectionResult } from './cursors';
 import { getLoaderMapping, setLoaderMappings } from './loader-map';
 import { ModelLoader } from './model-loader';
+import { PrismaObjectRef } from './object-ref';
 import { getDelegateFromModel, getFindUniqueForRef, getRefFromModel, getRelation } from './refs';
 import {
   PrismaDelegate,
@@ -21,7 +22,8 @@ import {
   RelatedFieldOptions,
   RelationCountOptions,
 } from './types';
-import { queryFromInfo } from './util';
+import { queryFromInfo, SELF_RELATION } from './util';
+import { VariantFieldOptions } from '.';
 
 export class PrismaObjectFieldBuilder<
   Types extends SchemaTypes,
@@ -69,6 +71,7 @@ export class PrismaObjectFieldBuilder<
       totalCount,
       ...options
     }: {
+      type?: ObjectRef<unknown, unknown>;
       totalCount?: boolean;
       maxSize?: number;
       defaultSize?: number;
@@ -84,7 +87,7 @@ export class PrismaObjectFieldBuilder<
     const parentRef = getRefFromModel(this.model, this.builder);
     const relationTypeName =
       typeof relationField.type === 'string' ? relationField.type : relationField.type.name;
-    const ref = getRefFromModel(relationTypeName, this.builder);
+    const ref = options.type ?? getRefFromModel(relationTypeName, this.builder);
     const findUnique = getFindUniqueForRef(parentRef, this.builder);
     const loaderCache = ModelLoader.forModel(this.model, this.builder);
     let typeName: string | undefined;
@@ -232,7 +235,7 @@ export class PrismaObjectFieldBuilder<
     const parentRef = getRefFromModel(this.model, this.builder);
     const relationTypeName =
       typeof relationField.type === 'string' ? relationField.type : relationField.type.name;
-    const ref = getRefFromModel(relationTypeName, this.builder);
+    const ref = options.type ?? getRefFromModel(relationTypeName, this.builder);
     const findUnique = getFindUniqueForRef(parentRef, this.builder);
     const loaderCache = ModelLoader.forModel(this.model, this.builder);
 
@@ -321,4 +324,50 @@ export class PrismaObjectFieldBuilder<
       },
     }) as FieldRef<number, 'Object'>;
   }
+
+  variant<Variant extends Model['Name'] | PrismaObjectRef<Model>>(
+    ...allArgs: NormalizeArgs<
+      [
+        variant: Variant,
+        options?: VariantFieldOptions<
+          Types,
+          Model,
+          Variant extends PrismaObjectRef<Model> ? Variant : PrismaObjectRef<Model>
+        >,
+      ]
+    >
+  ): FieldRef<Model['Shape'], 'Object'> {
+    const [variant, options = {} as never] = allArgs;
+    const ref: PrismaObjectRef<PrismaModelTypes> =
+      typeof variant === 'string' ? getRefFromModel(variant, this.builder) : variant;
+    const parentRef = getRefFromModel(this.model, this.builder);
+    const findUnique = getFindUniqueForRef(parentRef, this.builder);
+    const loaderCache = ModelLoader.forModel(this.model, this.builder);
+
+    return this.field({
+      ...options,
+      type: ref,
+      extensions: {
+        ...options.extensions,
+        pothosPrismaRelation: SELF_RELATION,
+      },
+      resolve: (parent, args, context, info) => {
+        const mapping = getLoaderMapping(context, info.path);
+
+        if (mapping) {
+          setLoaderMappings(context, info.path, mapping);
+
+          return parent as never;
+        }
+
+        const queryOptions = queryFromInfo(context, info);
+
+        if (!findUnique) {
+          throw new Error(`Missing findUnique for Prisma type ${this.model}`);
+        }
+
+        return loaderCache(parent).loadSelf(queryOptions, context) as never;
+      },
+    }) as FieldRef<Model['Shape'], 'Object'>;
+  }
 }

package/src/refs.ts

@@ -1,8 +1,10 @@
 import { ObjectRef, SchemaTypes } from '@pothos/core';
 import { Prisma } from '../tests/client';
+import { PrismaObjectRef } from './object-ref';
 import { PrismaDelegate } from './types';
+import { PrismaModelTypes } from '.';
 
-export const refMap = new WeakMap<object, Map<string, ObjectRef<unknown>>>();
+export const refMap = new WeakMap<object, Map<string, PrismaObjectRef<PrismaModelTypes>>>();
 export const findUniqueMap = new WeakMap<
   object,
   Map<ObjectRef<unknown>, ((args: unknown, ctx: {}) => unknown) | null>
@@ -16,14 +18,14 @@ export const includeForRefMap = new WeakMap<
 export function getRefFromModel<Types extends SchemaTypes>(
   name: string,
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
-): ObjectRef<unknown> {
+): PrismaObjectRef<PrismaModelTypes> {
   if (!refMap.has(builder)) {
     refMap.set(builder, new Map());
   }
   const cache = refMap.get(builder)!;
 
   if (!cache.has(name)) {
-    cache.set(name, builder.objectRef(name));
+    cache.set(name, new PrismaObjectRef(name));
   }
 
   return cache.get(name)!;