feat(zod): exclude relation fields from makeModelSchema by default

BREAKING CHANGE: `makeModelSchema()` no longer includes relation fields by default to prevent infinite nesting with circular relations and align with ORM behavior. Use `include` or `select` options to explicitly opt in to relation fields.

Author: marcsigmund

BREAKINGCHANGES.md

@@ -3,3 +3,4 @@
 1. non-optional to-one relation doesn't automatically filter parent read when evaluating access policies
 1. `@omit` and `@password` attributes have been removed
 1. SWR plugin is removed
+1. `makeModelSchema()` no longer includes relation fields by default — use `include` or `select` options to opt in, mirroring ORM behaviour

packages/zod/src/factory.ts

@@ -93,26 +93,16 @@ class SchemaFactory<Schema extends SchemaDef> {
         const modelDef = this.schema.requireModel(model);
 
         if (!options) {
-            // ── No-options path (original behaviour) ─────────────────────────
+            // ── No-options path: scalar fields only (relations excluded by default) ──
             const fields: Record<string, z.ZodType> = {};
 
             for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
-                if (fieldDef.relation) {
-                    const relatedModelName = fieldDef.type;
-                    const lazySchema: z.ZodType = z.lazy(() =>
-                        this.makeModelSchema(relatedModelName as GetModels<Schema>),
-                    );
-                    // relation fields are always optional
-                    fields[fieldName] = this.applyDescription(
-                        this.applyCardinality(lazySchema, fieldDef).optional(),
-                        fieldDef.attributes,
-                    );
-                } else {
-                    fields[fieldName] = this.applyDescription(
-                        this.makeScalarFieldSchema(fieldDef),
-                        fieldDef.attributes,
-                    );
-                }
+                // Relation fields are excluded by default — use `include` or `select`
+                // to opt in, mirroring ORM behaviour and avoiding infinite
+                // nesting for circular relations.
+                if (fieldDef.relation) continue;
+
+                fields[fieldName] = this.applyDescription(this.makeScalarFieldSchema(fieldDef), fieldDef.attributes);
             }
 
             const shape = z.strictObject(fields);

packages/zod/src/types.ts

@@ -20,15 +20,27 @@ import type {
 import type Decimal from 'decimal.js';
 import type z from 'zod';
 
+/**
+ * Scalar-only shape returned by the no-options `makeModelSchema` overload.
+ * Relation fields are excluded by default — use `include` or `select` to opt in.
+ */
 export type GetModelFieldsShape<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    // scalar fields
     [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true
         ? never
         : Field]: ZodOptionalAndNullableIf<
         ZodArrayIf<MapModelFieldToZod<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>>,
         ModelFieldIsOptional<Schema, Model, Field>
     >;
-} & {
+};
+
+/**
+ * Full shape including both scalar and relation fields — used internally for
+ * type lookups (e.g. resolving relation field Zod types in include/select).
+ */
+type GetAllModelFieldsShape<Schema extends SchemaDef, Model extends GetModels<Schema>> = GetModelFieldsShape<
+    Schema,
+    Model
+> & {
     // relation fields, always optional
     [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true
         ? Field
@@ -234,7 +246,7 @@ type FieldInShape<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Field extends GetModelFields<Schema, Model>,
-> = Field & keyof GetModelFieldsShape<Schema, Model>;
+> = Field & keyof GetAllModelFieldsShape<Schema, Model>;
 
 /**
  * Zod shape produced when a relation field is included via `include: { field:
@@ -246,7 +258,7 @@ type RelationFieldZodDefault<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Field extends GetModelFields<Schema, Model>,
-> = GetModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>];
+> = GetAllModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>];
 
 /**
  * Zod shape for a relation field included with nested options.  We recurse
@@ -288,7 +300,7 @@ type SelectEntryToZod<
       // Handling `boolean` (not just literal `true`) prevents the type from
       // collapsing to `never` when callers use a boolean variable instead of
       // a literal (e.g. `const pick: boolean = true`).
-      GetModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>]
+      GetAllModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>]
     : Value extends object
       ? // nested options — must be a relation field
         RelationFieldZodWithOptions<Schema, Model, Field, Value>
@@ -321,7 +333,7 @@ type BuildIncludeOmitShape<
               ? Field extends keyof O
                   ? never
                   : Field
-              : Field]: GetModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>];
+              : Field]: GetAllModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>];
     } & (I extends object // included relation fields
         ? {
               [Field in keyof I & GetModelFields<Schema, Model>]: I[Field] extends object

packages/zod/test/factory.test.ts

@@ -83,11 +83,8 @@ describe('SchemaFactory - makeModelSchema', () => {
             expectTypeOf<Address['zip']>().toEqualTypeOf<string | null | undefined>();
             expectTypeOf<User['address']>().toEqualTypeOf<Address | null | undefined>();
 
-            // relation field present
-            expectTypeOf<User>().toHaveProperty('posts');
-            const _postSchema = factory.makeModelSchema('Post');
-            type Post = z.infer<typeof _postSchema>;
-            expectTypeOf<User['posts']>().toEqualTypeOf<Post[] | undefined>();
+            // relation fields are NOT present by default — use include/select to opt in
+            expectTypeOf<User>().not.toHaveProperty('posts');
         });
 
         it('infers correct field types for Post', () => {
@@ -117,18 +114,22 @@ describe('SchemaFactory - makeModelSchema', () => {
 
             expectTypeOf<PostUpdate['tags']>().toEqualTypeOf<string[] | undefined>();
 
-            // optional relation field present in type
-            expectTypeOf<Post>().toHaveProperty('author');
-            const _userSchema = factory.makeModelSchema('User');
-            type User = z.infer<typeof _userSchema>;
-            expectTypeOf<Post['author']>().toEqualTypeOf<User | undefined | null>();
+            // relation fields are NOT present by default — use include/select to opt in
+            expectTypeOf<Post>().not.toHaveProperty('author');
         });
 
-        it('accepts a fully valid User', () => {
+        it('accepts a fully valid User (no relation fields)', () => {
             const userSchema = factory.makeModelSchema('User');
             expect(userSchema.safeParse(validUser).success).toBe(true);
         });
 
+        it('rejects relation fields in default schema (strict object)', () => {
+            const userSchema = factory.makeModelSchema('User');
+            // relation fields are not part of the default schema, so they are rejected
+            const result = userSchema.safeParse({ ...validUser, posts: [] });
+            expect(result.success).toBe(false);
+        });
+
         it('accepts a fully valid Post', () => {
             const postSchema = factory.makeModelSchema('Post');
             expect(postSchema.safeParse(validPost).success).toBe(true);