fix compatability with prisma 4.13.*

.changeset/clean-scissors-tickle.md

@@ -0,0 +1,5 @@
+---
+'@pothos/plugin-prisma': minor
+---
+
+Fix compatability with prisma@4.13.*

packages/plugin-prisma/src/util/datamodel.ts

@@ -67,7 +67,10 @@ export function getModel<Types extends SchemaTypes>(
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
 ) {
   const dmmf = getDMMF(builder);
-  const modelData = dmmf.datamodel.models.find((model) => model.name === name);
+
+  const modelData = Array.isArray(dmmf.models)
+    ? dmmf.models.find((model) => model.name === name)
+    : dmmf.models[name];
 
   if (!modelData) {
     throw new PothosSchemaError(`Model '${name}' not found in DMMF`);

packages/plugin-prisma/src/util/get-client.ts

@@ -17,7 +17,7 @@ export interface DMMFField {
   isUpdatedAt?: boolean;
 }
 
-interface DMMF {
+export interface DMMF {
   datamodel: {
     models: {
       name: string;
@@ -29,6 +29,18 @@ interface DMMF {
   };
 }
 
+export interface RuntimeDataModel {
+  models: Record<
+    string,
+    {
+      fields: DMMFField[];
+      primaryKey: { name: string | null; fields: string[] } | null;
+      uniqueIndexes: { name: string | null; fields: string[] }[];
+      documentation?: string;
+    }
+  >;
+}
+
 const prismaClientCache = createContextCache(
   <Types extends SchemaTypes>(builder: PothosSchemaTypes.SchemaBuilder<Types>) =>
     createContextCache((context: object) =>
@@ -51,15 +63,16 @@ export function getClient<Types extends SchemaTypes>(
 
 export function getDMMF<Types extends SchemaTypes>(
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
-): DMMF {
+): DMMF['datamodel'] | RuntimeDataModel {
   if ('dmmf' in builder.options.prisma && builder.options.prisma.dmmf) {
-    return builder.options.prisma.dmmf as DMMF;
+    return (builder.options.prisma.dmmf as DMMF).datamodel;
   }
 
   const client = builder.options.prisma.client as unknown as {
     _baseDmmf?: DMMF;
     _dmmf: DMMF;
+    _runtimeDataModel: RuntimeDataModel;
   };
 
-  return client._baseDmmf ?? client._dmmf;
+  return client._runtimeDataModel ?? client._baseDmmf?.datamodel ?? client._dmmf.datamodel;
 }

packages/plugin-prisma/src/util/relation-map.ts

@@ -1,5 +1,5 @@
 import { createContextCache } from '@pothos/core';
-import { DMMF } from '@prisma/generator-helper';
+import { DMMF, RuntimeDataModel } from './get-client';
 
 export interface FieldMap {
   model: string;
@@ -8,26 +8,42 @@ export interface FieldMap {
 
 export type RelationMap = Map<string, FieldMap>;
 
-export const getRelationMap = createContextCache((dmmf: { datamodel: unknown }) =>
-  createRelationMap(dmmf.datamodel as DMMF.Datamodel),
+export const getRelationMap = createContextCache(
+  (datamodel: DMMF['datamodel'] | RuntimeDataModel) => createRelationMap(datamodel),
 );
 
-export function createRelationMap({ models }: DMMF.Datamodel) {
+export function createRelationMap({ models }: DMMF['datamodel'] | RuntimeDataModel) {
   const relationMap: RelationMap = new Map();
 
-  models.forEach((model) => {
-    relationMap.set(model.name, { model: model.name, relations: new Map() });
-  });
+  if (Array.isArray(models)) {
+    models.forEach((model) => {
+      relationMap.set(model.name, { model: model.name, relations: new Map() });
+    });
+
+    models.forEach((model) => {
+      const map = relationMap.get(model.name)!.relations;
+
+      model.fields.forEach((field) => {
+        if (field.kind === 'object' && relationMap.has(field.type)) {
+          map.set(field.name, relationMap.get(field.type)!);
+        }
+      });
+    });
+  } else {
+    Object.keys(models).forEach((name) => {
+      relationMap.set(name, { model: name, relations: new Map() });
+    });
 
-  models.forEach((model) => {
-    const map = relationMap.get(model.name)!.relations;
+    Object.entries(models).forEach(([name, model]) => {
+      const map = relationMap.get(name)!.relations;
 
-    model.fields.forEach((field) => {
-      if (field.kind === 'object' && relationMap.has(field.type)) {
-        map.set(field.name, relationMap.get(field.type)!);
-      }
+      model.fields.forEach((field) => {
+        if (field.kind === 'object' && relationMap.has(field.type)) {
+          map.set(field.name, relationMap.get(field.type)!);
+        }
+      });
     });
-  });
+  }
 
   return relationMap;
 }