fix: don't set default value in nested writes when set through FK

Author: youssef-suhyl

packages/runtime/src/enhancements/node/default-auth.ts

@@ -5,10 +5,12 @@ import { ACTIONS_WITH_WRITE_PAYLOAD } from '../../constants';
 import {
     FieldInfo,
     NestedWriteVisitor,
+    NestedWriteVisitorContext,
     PrismaWriteActionType,
     clone,
     enumerate,
     getFields,
+    getModelInfo,
     getTypeDefInfo,
     requireField,
 } from '../../cross';
@@ -61,7 +63,7 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
     private async preprocessWritePayload(model: string, action: PrismaWriteActionType, args: any) {
         const newArgs = clone(args);
 
-        const processCreatePayload = (model: string, data: any) => {
+        const processCreatePayload = (model: string, data: any, context: NestedWriteVisitorContext) => {
             const fields = getFields(this.options.modelMeta, model);
             for (const fieldInfo of Object.values(fields)) {
                 if (fieldInfo.isTypeDef) {
@@ -82,24 +84,24 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
                 const defaultValue = this.getDefaultValue(fieldInfo);
                 if (defaultValue !== undefined) {
                     // set field value extracted from `auth()`
-                    this.setDefaultValueForModelData(fieldInfo, model, data, defaultValue);
+                    this.setDefaultValueForModelData(fieldInfo, model, data, defaultValue, context);
                 }
             }
         };
 
         // visit create payload and set default value to fields using `auth()` in `@default()`
         const visitor = new NestedWriteVisitor(this.options.modelMeta, {
-            create: (model, data) => {
-                processCreatePayload(model, data);
+            create: (model, data, context) => {
+                processCreatePayload(model, data, context);
             },
 
-            upsert: (model, data) => {
-                processCreatePayload(model, data.create);
+            upsert: (model, data, context) => {
+                processCreatePayload(model, data.create, context);
             },
 
-            createMany: (model, args) => {
+            createMany: (model, args, context) => {
                 for (const item of enumerate(args.data)) {
-                    processCreatePayload(model, item);
+                    processCreatePayload(model, item, context);
                 }
             },
         });
@@ -108,12 +110,32 @@ class DefaultAuthHandler extends DefaultPrismaProxyHandler {
         return newArgs;
     }
 
-    private setDefaultValueForModelData(fieldInfo: FieldInfo, model: string, data: any, authDefaultValue: unknown) {
+    private setDefaultValueForModelData(
+        fieldInfo: FieldInfo,
+        model: string,
+        data: any,
+        authDefaultValue: unknown,
+        context: NestedWriteVisitorContext
+    ) {
         if (fieldInfo.isForeignKey && fieldInfo.relationField && fieldInfo.relationField in data) {
             // if the field is a fk, and the relation field is already set, we should not override it
             return;
         }
 
+        if (context.field?.backLink) {
+            const modelInfo = getModelInfo(this.options.modelMeta, model);
+            const parentModel = modelInfo?.fields[context.field.backLink];
+
+            if (
+                parentModel?.isDataModel &&
+                parentModel.foreignKeyMapping &&
+                Object.keys(parentModel.foreignKeyMapping).includes(fieldInfo.name)
+            ) {
+                // if the field is part of a fk as part of a nested write, then prisma handles setting it
+                return;
+            }
+        }
+
         if (fieldInfo.isForeignKey && !isUnsafeMutate(model, data, this.options.modelMeta)) {
             // if the field is a fk, and the create payload is not unsafe, we need to translate
             // the fk field setting to a `connect` of the corresponding relation field

tests/regression/tests/issue-1989.test.ts

@@ -0,0 +1,121 @@
+import { loadSchema } from '@zenstackhq/testtools';
+
+describe('issue 1989', () => {
+    it('regression', async () => {
+        const { prisma, enhance } = await loadSchema(
+            `
+            model Tenant {
+                id            String          @id @default(uuid())
+            
+                users         User[]
+                posts         Post[]
+                comments      Comment[]
+                postUserLikes PostUserLikes[]
+            }
+            
+            model User {
+                id       String          @id @default(uuid())
+                tenantId String          @default(auth().tenantId)
+                tenant   Tenant          @relation(fields: [tenantId], references: [id])
+                posts    Post[]
+                likes    PostUserLikes[]
+            
+                @@allow('all', true)
+            }
+            
+            model Post {
+                tenantId String          @default(auth().tenantId)
+                tenant   Tenant          @relation(fields: [tenantId], references: [id])
+                id       String          @default(uuid())
+                author   User            @relation(fields: [authorId], references: [id])
+                authorId String          @default(auth().id)
+            
+                comments Comment[]
+                likes    PostUserLikes[]
+            
+                @@id([tenantId, id])
+            
+                @@allow('all', true)
+            }
+            
+            model PostUserLikes {
+                tenantId String @default(auth().tenantId)
+                tenant   Tenant @relation(fields: [tenantId], references: [id])
+                id       String @default(uuid())
+            
+                userId   String
+                user     User   @relation(fields: [userId], references: [id])
+            
+                postId   String
+                post     Post   @relation(fields: [tenantId, postId], references: [tenantId, id])
+            
+                @@id([tenantId, id])
+                @@unique([tenantId, userId, postId])
+            
+                @@allow('all', true)
+            }
+            
+            model Comment {
+                tenantId String @default(auth().tenantId)
+                tenant   Tenant @relation(fields: [tenantId], references: [id])
+                id       String @default(uuid())
+                postId   String
+                post     Post   @relation(fields: [tenantId, postId], references: [tenantId, id])
+            
+                @@id([tenantId, id])
+            
+                @@allow('all', true)
+            }
+            `,
+            { logPrismaQuery: true }
+        );
+
+        const tenant = await prisma.tenant.create({
+            data: {},
+        });
+        const user = await prisma.user.create({
+            data: { tenantId: tenant.id },
+        });
+
+        const db = enhance({ id: user.id, tenantId: tenant.id });
+
+        await expect(db.post.create({
+            data: {
+                likes: {
+                    createMany: {
+                        data: [{
+                            userId: user.id
+                        }]
+                    }
+                }
+            },
+            include: {
+                likes: true
+            }
+        })).resolves.toMatchObject({
+            authorId: user.id,
+            likes: [{
+                tenantId: tenant.id,
+                userId: user.id
+            }]
+        });
+
+        await expect(db.post.create({
+            data: {
+                comments: {
+                    createMany: {
+                        data: [{}]
+                    }
+                }
+            },
+            include: {
+                comments: true
+            }
+        })).resolves.toMatchObject({
+            authorId: user.id,
+            comments: [{
+                tenantId: tenant.id
+            }]
+        });
+    });
+});