fix(delegate): filter fixes

ymc9 · ymc9 · commit c19427b1dc59 · 2025-07-24T23:07:52.000+08:00
diff --git a/packages/runtime/src/client/crud/dialects/base.ts b/packages/runtime/src/client/crud/dialects/base.ts
diff --git a/packages/runtime/src/client/crud/dialects/postgresql.ts b/packages/runtime/src/client/crud/dialects/postgresql.ts
@@ -81,17 +81,14 @@ export class PostgresCrudDialect<Schema extends SchemaDef> extends BaseCrudDiale
                 // simple select by default
                 let result = eb.selectFrom(`${relationModel} as ${joinTableName}`);
 
-                const joinBases: string[] = [];
-
                 // however if there're filter/orderBy/take/skip,
                 // we need to build a subquery to handle them before aggregation
                 result = eb.selectFrom(() => {
-                    let subQuery = eb.selectFrom(relationModel);
+                    let subQuery = this.buildSelectModel(eb, relationModel);
                     subQuery = this.buildSelectAllFields(
                         relationModel,
                         subQuery,
                         typeof payload === 'object' ? payload?.omit : undefined,
-                        joinBases,
                     );
 
                     if (payload && typeof payload === 'object') {
diff --git a/packages/runtime/src/client/crud/dialects/sqlite.ts b/packages/runtime/src/client/crud/dialects/sqlite.ts
@@ -77,14 +77,12 @@ export class SqliteCrudDialect<Schema extends SchemaDef> extends BaseCrudDialect
         const subQueryName = `${parentName}$${relationField}`;
 
         let tbl = eb.selectFrom(() => {
-            let subQuery = eb.selectFrom(relationModel);
+            let subQuery = this.buildSelectModel(eb, relationModel);
 
-            const joinBases: string[] = [];
             subQuery = this.buildSelectAllFields(
                 relationModel,
                 subQuery,
                 typeof payload === 'object' ? payload?.omit : undefined,
-                joinBases,
             );
 
             if (payload && typeof payload === 'object') {
diff --git a/packages/runtime/src/client/crud/operations/base.ts b/packages/runtime/src/client/crud/operations/base.ts
@@ -143,7 +143,7 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
         args: FindArgs<Schema, GetModels<Schema>, true> | undefined,
     ): Promise<any[]> {
         // table
-        let query = kysely.selectFrom(model);
+        let query = this.dialect.buildSelectModel(expressionBuilder(), model);
 
         // where
         if (args?.where) {
@@ -182,22 +182,19 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
             }
         }
 
-        // for deduplicating base joins
-        const joinedBases: string[] = [];
-
         // select
         if (args && 'select' in args && args.select) {
             // select is mutually exclusive with omit
-            query = this.buildFieldSelection(model, query, args.select, model, joinedBases);
+            query = this.buildFieldSelection(model, query, args.select, model);
         } else {
             // include all scalar fields except those in omit
-            query = this.dialect.buildSelectAllFields(model, query, (args as any)?.omit, joinedBases);
+            query = this.dialect.buildSelectAllFields(model, query, (args as any)?.omit);
         }
 
         // include
         if (args && 'include' in args && args.include) {
             // note that 'omit' is handled above already
-            query = this.buildFieldSelection(model, query, args.include, model, joinedBases);
+            query = this.buildFieldSelection(model, query, args.include, model);
         }
 
         if (args?.cursor) {
@@ -207,13 +204,15 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
         query = query.modifyEnd(this.makeContextComment({ model, operation: 'read' }));
 
         let result: any[] = [];
+        const queryId = { queryId: `zenstack-${createId()}` };
+        const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), queryId);
         try {
-            result = await query.execute();
+            const r = await kysely.getExecutor().executeQuery(compiled, queryId);
+            result = r.rows;
         } catch (err) {
-            const { sql, parameters } = query.compile();
-            let message = `Failed to execute query: ${err}, sql: ${sql}`;
+            let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
             if (this.options.debug) {
-                message += `, parameters: \n${parameters.map((p) => inspect(p)).join('\n')}`;
+                message += `, parameters: \n${compiled.parameters.map((p) => inspect(p)).join('\n')}`;
             }
             throw new QueryError(message, err);
         }
@@ -248,7 +247,6 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
         query: SelectQueryBuilder<any, any, any>,
         selectOrInclude: Record<string, any>,
         parentAlias: string,
-        joinedBases: string[],
     ) {
         let result = query;
 
@@ -265,17 +263,12 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
             const fieldDef = this.requireField(model, field);
             if (!fieldDef.relation) {
                 // scalar field
-                result = this.dialect.buildSelectField(result, model, parentAlias, field, joinedBases);
+                result = this.dialect.buildSelectField(result, model, parentAlias, field);
             } else {
                 if (!fieldDef.array && !fieldDef.optional && payload.where) {
                     throw new QueryError(`Field "${field}" doesn't support filtering`);
                 }
                 if (fieldDef.originModel) {
-                    // relation is inherited from a delegate base model, need to build a join
-                    if (!joinedBases.includes(fieldDef.originModel)) {
-                        joinedBases.push(fieldDef.originModel);
-                        result = this.dialect.buildDelegateJoin(parentAlias, fieldDef.originModel, result);
-                    }
                     result = this.dialect.buildRelationSelection(
                         result,
                         fieldDef.originModel,
@@ -399,8 +392,15 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
         model: GetModels<Schema>,
         data: any,
         fromRelation?: FromRelationContext<Schema>,
+        creatingForDelegate = false,
     ): Promise<unknown> {
         const modelDef = this.requireModel(model);
+
+        // additional validations
+        if (modelDef.isDelegate && !creatingForDelegate) {
+            throw new QueryError(`Model "${this.model}" is a delegate and cannot be created directly.`);
+        }
+
         let createFields: any = {};
         let parentUpdateTask: ((entity: any) => Promise<unknown>) | undefined = undefined;
 
@@ -573,7 +573,7 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
         thisCreateFields[discriminatorField] = forModel;
 
         // create base model entity
-        const createResult = await this.create(kysely, model as GetModels<Schema>, thisCreateFields);
+        const createResult = await this.create(kysely, model as GetModels<Schema>, thisCreateFields, undefined, true);
 
         // copy over id fields from base model
         const idValues = extractIdFields(createResult, this.schema, model);
diff --git a/packages/runtime/src/client/crud/operations/create.ts b/packages/runtime/src/client/crud/operations/create.ts
@@ -4,15 +4,9 @@ import type { GetModels, SchemaDef } from '../../../schema';
 import type { CreateArgs, CreateManyAndReturnArgs, CreateManyArgs, WhereInput } from '../../crud-types';
 import { getIdValues } from '../../query-utils';
 import { BaseOperationHandler } from './base';
-import { QueryError } from '../../errors';
 
 export class CreateOperationHandler<Schema extends SchemaDef> extends BaseOperationHandler<Schema> {
     async handle(operation: 'create' | 'createMany' | 'createManyAndReturn', args: unknown | undefined) {
-        const modelDef = this.requireModel(this.model);
-        if (modelDef.isDelegate) {
-            throw new QueryError(`Model "${this.model}" is a delegate and cannot be created directly.`);
-        }
-
         // normalize args to strip `undefined` fields
         const normalizedArgs = this.normalizeArgs(args);
 
diff --git a/packages/runtime/test/client-api/delegate.test.ts b/packages/runtime/test/client-api/delegate.test.ts
@@ -78,6 +78,15 @@ model Gallery {
                     },
                 }),
             ).rejects.toThrow('is a delegate');
+            await expect(
+                client.user.create({
+                    data: {
+                        assets: {
+                            create: { assetType: 'Video' },
+                        },
+                    },
+                }),
+            ).rejects.toThrow('is a delegate');
 
             // create entity with two levels of delegation
             await expect(
@@ -242,5 +251,183 @@ model Gallery {
                 ratedVideos: [{ url: 'abc', rating: 5 }],
             });
         });
+
+        describe('Delegate filter tests', async () => {
+            beforeEach(async () => {
+                const u = await client.user.create({
+                    data: {
+                        email: 'u1@example.com',
+                    },
+                });
+                await client.ratedVideo.create({
+                    data: {
+                        viewCount: 0,
+                        duration: 100,
+                        url: 'v1',
+                        rating: 5,
+                        owner: { connect: { id: u.id } },
+                        user: { connect: { id: u.id } },
+                    },
+                });
+                await client.ratedVideo.create({
+                    data: {
+                        viewCount: 1,
+                        duration: 200,
+                        url: 'v2',
+                        rating: 4,
+                        owner: { connect: { id: u.id } },
+                        user: { connect: { id: u.id } },
+                    },
+                });
+            });
+
+            it('works with toplevel filters', async () => {
+                await expect(
+                    client.asset.findMany({
+                        where: { viewCount: { gt: 0 } },
+                    }),
+                ).toResolveWithLength(1);
+
+                await expect(
+                    client.video.findMany({
+                        where: { viewCount: { gt: 0 }, url: 'v1' },
+                    }),
+                ).toResolveWithLength(0);
+
+                await expect(
+                    client.video.findMany({
+                        where: { viewCount: { gt: 0 }, url: 'v2' },
+                    }),
+                ).toResolveWithLength(1);
+
+                await expect(
+                    client.ratedVideo.findMany({
+                        where: { viewCount: { gt: 0 }, rating: 5 },
+                    }),
+                ).toResolveWithLength(0);
+
+                await expect(
+                    client.ratedVideo.findMany({
+                        where: { viewCount: { gt: 0 }, rating: 4 },
+                    }),
+                ).toResolveWithLength(1);
+            });
+
+            it('works with filtering relations', async () => {
+                await expect(
+                    client.user.findFirst({
+                        include: {
+                            assets: {
+                                where: { viewCount: { gt: 0 } },
+                            },
+                        },
+                    }),
+                ).resolves.toSatisfy((user) => user.assets.length === 1);
+
+                await expect(
+                    client.user.findFirst({
+                        include: {
+                            ratedVideos: {
+                                where: { viewCount: { gt: 0 }, url: 'v1' },
+                            },
+                        },
+                    }),
+                ).resolves.toSatisfy((user) => user.ratedVideos.length === 0);
+
+                await expect(
+                    client.user.findFirst({
+                        include: {
+                            ratedVideos: {
+                                where: { viewCount: { gt: 0 }, url: 'v2' },
+                            },
+                        },
+                    }),
+                ).resolves.toSatisfy((user) => user.ratedVideos.length === 1);
+
+                await expect(
+                    client.user.findFirst({
+                        include: {
+                            ratedVideos: {
+                                where: { viewCount: { gt: 0 }, rating: 5 },
+                            },
+                        },
+                    }),
+                ).resolves.toSatisfy((user) => user.ratedVideos.length === 0);
+
+                await expect(
+                    client.user.findFirst({
+                        include: {
+                            ratedVideos: {
+                                where: { viewCount: { gt: 0 }, rating: 4 },
+                            },
+                        },
+                    }),
+                ).resolves.toSatisfy((user) => user.ratedVideos.length === 1);
+            });
+
+            it('works with filtering parents', async () => {
+                await expect(
+                    client.user.findFirst({
+                        where: {
+                            assets: {
+                                some: { viewCount: { gt: 0 } },
+                            },
+                        },
+                    }),
+                ).toResolveTruthy();
+
+                await expect(
+                    client.user.findFirst({
+                        where: {
+                            assets: {
+                                some: { viewCount: { gt: 1 } },
+                            },
+                        },
+                    }),
+                ).toResolveFalsy();
+
+                await expect(
+                    client.user.findFirst({
+                        where: {
+                            ratedVideos: {
+                                some: { viewCount: { gt: 0 }, url: 'v1' },
+                            },
+                        },
+                    }),
+                ).toResolveFalsy();
+
+                await expect(
+                    client.user.findFirst({
+                        where: {
+                            ratedVideos: {
+                                some: { viewCount: { gt: 0 }, url: 'v2' },
+                            },
+                        },
+                    }),
+                ).toResolveTruthy();
+            });
+
+            it('works with filtering with relations from base', async () => {
+                await expect(
+                    client.video.findFirst({
+                        where: {
+                            owner: {
+                                email: 'u1@example.com',
+                            },
+                        },
+                    }),
+                ).toResolveTruthy();
+
+                await expect(
+                    client.video.findFirst({
+                        where: {
+                            owner: {
+                                email: 'u2@example.com',
+                            },
+                        },
+                    }),
+                ).toResolveFalsy();
+            });
+        });
     },
 );
diff --git a/packages/runtime/test/client-api/typed-json-fields.test.ts b/packages/runtime/test/client-api/typed-json-fields.test.ts
@@ -29,7 +29,6 @@ model User {
                 usePrismaPush: true,
                 provider,
                 dbName: provider === 'postgresql' ? PG_DB_NAME : undefined,
-                log: ['query'],
             });
         });
 
