fix: relation selection input validation issue

packages/runtime/src/client/crud-types.ts

@@ -631,16 +631,15 @@ export type FindArgs<
           skip?: number;
           take?: number;
           orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
-      }
+      } & Distinct<Schema, Model> &
+          Cursor<Schema, Model>
     : {}) &
     (AllowFilter extends true
         ? {
               where?: WhereInput<Schema, Model>;
           }
         : {}) &
-    SelectIncludeOmit<Schema, Model, Collection> &
-    Distinct<Schema, Model> &
-    Cursor<Schema, Model>;
+    SelectIncludeOmit<Schema, Model, Collection>;
 
 export type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
 export type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, false>;

packages/runtime/src/client/crud/validator.ts

@@ -593,8 +593,27 @@ export class InputValidator<Schema extends SchemaDef> {
                     .union([
                         z.literal(true),
                         z.strictObject({
+                            ...(fieldDef.array || fieldDef.optional
+                                ? {
+                                      // to-many relations and optional to-one relations are filterable
+                                      where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional(),
+                                  }
+                                : {}),
                             select: z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
                             include: z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
+                            omit: z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
+                            ...(fieldDef.array
+                                ? {
+                                      // to-many relations can be ordered, skipped, taken, and cursor-located
+                                      orderBy: z
+                                          .lazy(() => this.makeOrderBySchema(fieldDef.type, true, false))
+                                          .optional(),
+                                      skip: this.makeSkipSchema().optional(),
+                                      take: this.makeTakeSchema().optional(),
+                                      cursor: this.makeCursorSchema(fieldDef.type).optional(),
+                                      distinct: this.makeDistinctSchema(fieldDef.type).optional(),
+                                  }
+                                : {}),
                         }),
                     ])
                     .optional();

packages/runtime/test/client-api/find.test.ts

@@ -637,6 +637,54 @@ describe.each(createClientSpecs(PG_DB_NAME))('Client find tests for $provider',
         expect(r?.posts[0]?.createdAt).toBeInstanceOf(Date);
         expect(r?.posts[0]?.published).toBeTypeOf('boolean');
 
+        await expect(
+            client.user.findUnique({
+                where: { id: user.id },
+                select: {
+                    posts: { where: { published: true }, select: { title: true }, orderBy: { createdAt: 'desc' } },
+                },
+            }),
+        ).resolves.toMatchObject({
+            posts: [expect.objectContaining({ title: 'Post1' })],
+        });
+
+        await expect(
+            client.user.findUnique({
+                where: { id: user.id },
+                select: {
+                    posts: { orderBy: { title: 'asc' }, skip: 1, take: 1, distinct: ['title'] },
+                },
+            }),
+        ).resolves.toMatchObject({
+            posts: [expect.objectContaining({ title: 'Post2' })],
+        });
+
+        await expect(
+            client.post.findFirst({
+                select: { author: { select: { email: true } } },
+            }),
+        ).resolves.toMatchObject({
+            author: { email: expect.any(String) },
+        });
+
+        await expect(
+            client.user.findUnique({
+                where: { id: user.id },
+                include: {
+                    profile: { where: { bio: 'My bio' } },
+                },
+            }),
+        ).resolves.toMatchObject({ profile: expect.any(Object) });
+
+        await expect(
+            client.user.findUnique({
+                where: { id: user.id },
+                include: {
+                    profile: { where: { bio: 'Other bio' } },
+                },
+            }),
+        ).resolves.toMatchObject({ profile: null });
+
         await expect(
             client.user.findUnique({
                 where: { id: user.id },