add createOpposite option on @relation

Author: elliots

packages/cli/test/plugins/prisma-plugin.test.ts

@@ -78,4 +78,45 @@ model User {
         runCli('generate', workDir);
         expect(fs.existsSync(path.join(workDir, 'relative/schema.prisma'))).toBe(true);
     });
+
+    it('should auto-generate opposite relation field with createOpposite: true', async () => {
+        const { workDir } = await createProject(`
+plugin prisma {
+    provider = '@core/prisma'
+}
+
+model User {
+    id String @id @default(cuid())
+}
+
+model Post {
+    id       String @id @default(cuid())
+    userId   String
+    user     User   @relation(fields: [userId], references: [id], createOpposite: true)
+}
+`);
+        runCli('generate', workDir);
+        const prismaSchema = fs.readFileSync(path.join(workDir, 'zenstack/schema.prisma'), 'utf8');
+        expect(prismaSchema).toContain('post Post[]');
+        expect(prismaSchema).not.toContain('createOpposite');
+    });
+
+    it('should error on missing opposite relation without createOpposite', async () => {
+        const { workDir } = await createProject(`
+plugin prisma {
+    provider = '@core/prisma'
+}
+
+model User {
+    id String @id @default(cuid())
+}
+
+model Post {
+    id       String @id @default(cuid())
+    userId   String
+    user     User   @relation(fields: [userId], references: [id])
+}
+`);
+        expect(() => runCli('generate', workDir)).toThrow(/missing an opposite relation/);
+    });
 });

packages/language/res/stdlib.zmodel

@@ -364,8 +364,9 @@ attribute @@index(_ fields: FieldReference[], name: String?, map: String?, lengt
  * @param map: Defines a custom name for the foreign key in the database.
  * @param onUpdate: Defines the referential action to perform when a referenced entry in the referenced model is being updated.
  * @param onDelete: Defines the referential action to perform when a referenced entry in the referenced model is being deleted.
+ * @param createOpposite: When true, auto-generates the opposite relation field in the Prisma schema.
  */
-attribute @relation(_ name: String?, fields: FieldReference[]?, references: TransitiveFieldReference[]?, onDelete: ReferentialAction?, onUpdate: ReferentialAction?, map: String?) @@@prisma
+attribute @relation(_ name: String?, fields: FieldReference[]?, references: TransitiveFieldReference[]?, onDelete: ReferentialAction?, onUpdate: ReferentialAction?, map: String?, createOpposite: Boolean?) @@@prisma
 
 /**
  * Maps a field name or enum value from the schema to a column with a different name in the database.

packages/language/src/validators/datamodel-validator.ts

@@ -7,6 +7,7 @@ import {
     DataModel,
     ReferenceExpr,
     TypeDef,
+    isBooleanLiteral,
     isDataModel,
     isEnum,
     isStringLiteral,
@@ -258,6 +259,12 @@ export default class DataModelValidator implements AstValidator<DataModel> {
         });
 
         if (oppositeFields.length === 0) {
+            // skip error if createOpposite: true is set — the opposite will be auto-generated
+            const createOppositeArg = thisRelation.attr?.args.find((a) => a.name === 'createOpposite');
+            if (createOppositeArg && isBooleanLiteral(createOppositeArg.value) && createOppositeArg.value.value === true) {
+                return;
+            }
+
             const info: DiagnosticInfo<AstNode, string> = {
                 node: field,
                 code: IssueCodes.MissingOppositeRelation,

packages/sdk/src/prisma/prisma-builder.ts

@@ -44,6 +44,10 @@ export class PrismaModel {
         return e;
     }
 
+    findModel(name: string): Model | undefined {
+        return this.models.find((m) => m.name === name);
+    }
+
     toString(): string {
         return [...this.datasources, ...this.generators, ...this.enums, ...this.models]
             .map((d) => d.toString())

packages/sdk/src/prisma/prisma-schema-generator.ts

@@ -111,6 +111,9 @@ export class PrismaSchemaGenerator {
             this.generateDefaultGenerator(prisma);
         }
 
+        // auto-generate missing opposite relation fields so Prisma schema is always valid
+        this.generateMissingOppositeRelations(prisma);
+
         return this.PRELUDE + prisma.toString();
     }
 
@@ -335,12 +338,15 @@ export class PrismaSchemaGenerator {
         return AstUtils.streamAst(expr).some(isAuthInvocation);
     }
 
+    // Args that are ZenStack-only and should not appear in the generated Prisma schema
+    private readonly NON_PRISMA_RELATION_ARGS = ['createOpposite'];
+
     private makeFieldAttribute(attr: DataFieldAttribute) {
         const attrName = attr.decl.ref!.name;
-        return new PrismaFieldAttribute(
-            attrName,
-            attr.args.map((arg) => this.makeAttributeArg(arg)),
-        );
+        const args = attr.args
+            .filter((arg) => !(attrName === '@relation' && arg.name && this.NON_PRISMA_RELATION_ARGS.includes(arg.name)))
+            .map((arg) => this.makeAttributeArg(arg));
+        return new PrismaFieldAttribute(attrName, args);
     }
 
     private makeAttributeArg(arg: AttributeArg): PrismaAttributeArg {
@@ -512,6 +518,90 @@ export class PrismaSchemaGenerator {
         );
     }
 
+    private hasCreateReverse(field: DataField): boolean {
+        const relAttr = field.attributes.find((attr) => attr.decl.ref?.name === '@relation');
+        if (!relAttr) return false;
+        const createOppositeArg = relAttr.args.find((arg) => arg.name === 'createOpposite');
+        if (!createOppositeArg) return false;
+        return isLiteralExpr(createOppositeArg.value) && createOppositeArg.value.value === true;
+    }
+
+    /**
+     * For relation fields with `createOpposite: true`, auto-generates the opposite relation
+     * field in the Prisma schema so it stays valid.
+     */
+    private generateMissingOppositeRelations(prisma: PrismaModel) {
+        for (const decl of this.zmodel.declarations) {
+            if (!isDataModel(decl)) continue;
+
+            const allFields = getAllFields(decl, false);
+            for (const field of allFields) {
+                if (!isDataModel(field.type.reference?.ref)) continue;
+                if (!this.hasCreateReverse(field)) continue;
+
+                const oppositeModel = field.type.reference!.ref! as DataModel;
+                const oppositeFields = getAllFields(oppositeModel, false).filter(
+                    (f) => f !== field && f.type.reference?.ref?.name === decl.name,
+                );
+
+                if (oppositeFields.length === 0) {
+                    // missing opposite relation — add it to the Prisma model
+                    const prismaOppositeModel = prisma.findModel(oppositeModel.name);
+                    if (!prismaOppositeModel) continue;
+
+                    const fieldName = lowerCaseFirst(decl.name);
+                    // check if a field with this name already exists in the Prisma model
+                    if (prismaOppositeModel.fields.some((f) => f.name === fieldName)) continue;
+
+                    if (field.type.array) {
+                        // the field is an array (e.g., posts Post[]), so the opposite should be a scalar relation
+                        const idFields = getIdFields(prismaOppositeModel.name === decl.name ? decl : oppositeModel);
+                        if (idFields.length === 0) continue;
+
+                        const idFieldName = idFields[0]!;
+                        const refIdFieldName = fieldName + idFieldName.charAt(0).toUpperCase() + idFieldName.slice(1);
+                        // add FK field if not present
+                        if (!prismaOppositeModel.fields.some((f) => f.name === refIdFieldName)) {
+                            const idField = allFields.find((f) => f.name === idFieldName);
+                            if (idField?.type.type) {
+                                prismaOppositeModel.addField(
+                                    refIdFieldName,
+                                    new ModelFieldType(idField.type.type, false, false),
+                                );
+                            }
+                        }
+                        prismaOppositeModel.addField(
+                            fieldName,
+                            new ModelFieldType(decl.name, false, false),
+                            [
+                                new PrismaFieldAttribute('@relation', [
+                                    new PrismaAttributeArg(
+                                        'fields',
+                                        new PrismaAttributeArgValue('Array', [
+                                            new PrismaAttributeArgValue('FieldReference', new PrismaFieldReference(refIdFieldName)),
+                                        ]),
+                                    ),
+                                    new PrismaAttributeArg(
+                                        'references',
+                                        new PrismaAttributeArgValue('Array', [
+                                            new PrismaAttributeArgValue('FieldReference', new PrismaFieldReference(idFieldName)),
+                                        ]),
+                                    ),
+                                ]),
+                            ],
+                        );
+                    } else {
+                        // the field is a scalar relation (e.g., greeting Greeting), so the opposite should be an array
+                        prismaOppositeModel.addField(
+                            fieldName,
+                            new ModelFieldType(decl.name, true, false),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
     private truncate(name: string) {
         if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) {
             return name;