fix(polymorphism): createMany is handled incorrectly

packages/runtime/src/enhancements/delegate.ts

@@ -390,7 +390,7 @@ export class DelegateProxyHandler extends DefaultPrismaProxyHandler {
         return this.queryUtils.transaction(this.prisma, async (tx) => {
             const r = await Promise.all(
                 enumerate(args.data).map(async (item) => {
-                    return this.doCreate(tx, this.model, item);
+                    return this.doCreate(tx, this.model, { data: item });
                 })
             );
 

tests/integration/tests/enhancements/with-delegate/enhanced-client.test.ts

@@ -121,6 +121,43 @@ describe('Polymorphism Test', () => {
         ).resolves.toMatchObject({ owner: { id: 2 } });
     });
 
+    it('create many polymorphic model', async () => {
+        const { enhance } = await loadSchema(schema, { logPrismaQuery: true, enhancements: ['delegate'] });
+        const db = enhance();
+
+        await expect(
+            db.ratedVideo.createMany({ data: { viewCount: 1, duration: 100, url: 'xyz', rating: 100 } })
+        ).resolves.toMatchObject({ count: 1 });
+
+        await expect(
+            db.ratedVideo.createMany({
+                data: [
+                    { viewCount: 2, duration: 200, url: 'xyz', rating: 100 },
+                    { viewCount: 3, duration: 300, url: 'xyz', rating: 100 },
+                ],
+            })
+        ).resolves.toMatchObject({ count: 2 });
+    });
+
+    it('create many polymorphic relation', async () => {
+        const { enhance } = await loadSchema(schema, { logPrismaQuery: true, enhancements: ['delegate'] });
+        const db = enhance();
+
+        const video1 = await db.ratedVideo.create({
+            data: { viewCount: 1, duration: 100, url: 'xyz', rating: 100 },
+        });
+        await expect(
+            db.user.createMany({ data: { id: 1, assets: { connect: { id: video1.id } } } })
+        ).resolves.toMatchObject({ count: 1 });
+
+        const video2 = await db.ratedVideo.create({
+            data: { viewCount: 1, duration: 100, url: 'xyz', rating: 100 },
+        });
+        await expect(
+            db.user.createMany({ data: [{ id: 2, assets: { connect: { id: video2.id } } }, { id: 3 }] })
+        ).resolves.toMatchObject({ count: 2 });
+    });
+
     it('read with concrete', async () => {
         const { db, user, video } = await setup();
 

tests/integration/tests/enhancements/with-delegate/issue-1149.test.ts

@@ -0,0 +1,112 @@
+import { createPostgresDb, dropPostgresDb, loadSchema } from '@zenstackhq/testtools';
+
+describe('Regression for issue 1149', () => {
+    let prisma: any;
+    let dbUrl: string;
+
+    beforeAll(async () => {
+        dbUrl = await createPostgresDb('issue-1149');
+    });
+
+    afterAll(async () => {
+        if (prisma) {
+            await prisma.$disconnect();
+        }
+        dropPostgresDb('issue-1149');
+    });
+
+    it('test', async () => {
+        const schema = `
+        model User {
+          id String @id @default(cuid())
+          name String
+        
+          userRankings UserRanking[]
+          userFavorites UserFavorite[]
+        }
+        
+        model Entity {
+          id String @id @default(cuid())
+          name String
+          type String
+          userRankings UserRanking[]
+          userFavorites UserFavorite[]
+        
+          @@delegate(type)
+        }
+        
+        model Person extends Entity {
+        }
+        
+        model Studio extends Entity {
+        }
+        
+        
+        model UserRanking {
+          id String @id @default(cuid())
+          rank Int
+        
+          entityId String
+          entity Entity @relation(fields: [entityId], references: [id], onUpdate: NoAction)
+          userId String
+          user User @relation(fields: [userId], references: [id], onDelete: Cascade, onUpdate: NoAction)
+        }
+        
+        model UserFavorite {
+          id String @id @default(cuid())
+        
+          entityId String
+          entity Entity @relation(fields: [entityId], references: [id], onUpdate: NoAction)
+          userId String
+          user User @relation(fields: [userId], references: [id], onDelete: Cascade, onUpdate: NoAction)
+        } 
+        `;
+
+        const { enhance, prisma: _prisma } = await loadSchema(schema, {
+            provider: 'postgresql',
+            dbUrl,
+            enhancements: ['delegate'],
+        });
+
+        prisma = _prisma;
+        const db = enhance();
+
+        const user = await db.user.create({ data: { name: 'user' } });
+        const person = await db.person.create({ data: { name: 'person' } });
+
+        await expect(
+            db.userRanking.createMany({
+                data: {
+                    rank: 1,
+                    entity: { connect: { id: person.id } },
+                    user: { connect: { id: user.id } },
+                },
+            })
+        ).resolves.toMatchObject({ count: 1 });
+
+        await expect(
+            db.userRanking.createMany({
+                data: [
+                    {
+                        rank: 2,
+                        entity: { connect: { id: person.id } },
+                        user: { connect: { id: user.id } },
+                    },
+                    {
+                        rank: 3,
+                        entity: { connect: { id: person.id } },
+                        user: { connect: { id: user.id } },
+                    },
+                ],
+            })
+        ).resolves.toMatchObject({ count: 2 });
+
+        await expect(db.userRanking.findMany()).resolves.toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({ rank: 1 }),
+                expect.objectContaining({ rank: 2 }),
+                expect.objectContaining({ rank: 3 }),
+            ])
+        );
+    });
+});