$is filter uses camelCase keys and true for presence checks (#10)

Author: motopods

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

@@ -353,16 +353,18 @@ export type WhereInput<
 
 /**
  * Where filter that targets a specific sub-model of a delegate (polymorphic) base model.
- * Keys are direct sub-model names; values are `WhereInput` for that sub-model.
- * Multiple sub-model entries are combined with OR semantics.
+ * Keys are camelCase sub-model names; values are `true` (match any instance) or a `WhereInput`
+ * for that sub-model. Multiple sub-model entries are combined with OR semantics.
  */
 export type SubModelWhereInput<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
     ScalarOnly extends boolean = false,
 > = {
-    [SubModel in GetSubModels<Schema, Model>]?: WhereInput<Schema, SubModel, Options, ScalarOnly> | null;
+    [SubModel in GetSubModels<Schema, Model> as Uncapitalize<SubModel & string>]?:
+        | true
+        | WhereInput<Schema, SubModel, Options, ScalarOnly>;
 };
 
 type FieldFilter<

packages/orm/src/client/crud/dialects/base-dialect.ts

@@ -327,8 +327,8 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
 
     /**
      * Builds a filter expression for the `$is` operator on a delegate (polymorphic) base model.
-     * Each key in `payload` is a direct sub-model name; the value is an optional `WhereInput` for
-     * that sub-model. Multiple sub-model entries are combined with OR semantics.
+     * Each key in `payload` is a camelCase sub-model name; the value is `true` (match any instance)
+     * or a `WhereInput` for that sub-model. Multiple sub-model entries are combined with OR semantics.
      */
     private buildIsFilter(model: string, modelAlias: string, payload: Record<string, any>): Expression<SqlBool> {
         const discriminatorField = getDiscriminatorField(this.schema, model);
@@ -345,11 +345,21 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
 
         const conditions: Expression<SqlBool>[] = [];
 
-        for (const [subModelName, subWhere] of Object.entries(payload)) {
+        for (const [subModelKey, subWhere] of Object.entries(payload)) {
+            // Map camelCase user-facing key back to PascalCase model name. ZenStack model names are
+            // always PascalCase (e.g. RatedVideo), so the camelCase key is simply the first character
+            // lowercased (e.g. ratedVideo). Uppercasing the first character recovers the original name.
+            const subModelName = subModelKey.charAt(0).toUpperCase() + subModelKey.slice(1);
             // discriminator must equal the sub-model name
             const discriminatorCheck = this.eb(discriminatorRef, '=', subModelName);
 
-            if (subWhere == null || (typeof subWhere === 'object' && Object.keys(subWhere).length === 0)) {
+            // `true`, null, or an empty object all mean "match any instance of this sub-model type"
+            const isMatchAny =
+                subWhere === true ||
+                subWhere == null ||
+                (typeof subWhere === 'object' && Object.keys(subWhere).length === 0);
+
+            if (isMatchAny) {
                 // no sub-model field filter — just check the discriminator
                 conditions.push(discriminatorCheck);
             } else {

packages/orm/src/client/zod/factory.ts

@@ -490,10 +490,12 @@ export class ZodSchemaFactory<
             const subModelSchema = z.object(
                 Object.fromEntries(
                     modelDef.subModels.map((subModel) => [
-                        subModel,
+                        subModel.charAt(0).toLowerCase() + subModel.slice(1),
                         z
-                            .lazy(() => this.makeWhereSchema(subModel, false, false, false, options))
-                            .nullish()
+                            .union([
+                                z.literal(true),
+                                z.lazy(() => this.makeWhereSchema(subModel, false, false, false, options)),
+                            ])
                             .optional(),
                     ]),
                 ),

tests/e2e/orm/client-api/delegate.test.ts

@@ -564,59 +564,52 @@ describe('Delegate model tests ', () => {
                 data: { format: 'png', viewCount: 2 },
             });
 
-            // $is: { Video: {} } — all assets that are Videos (2 RatedVideos)
+            // $is: { video: true } — all assets that are Videos (2 RatedVideos)
             await expect(
                 client.asset.findMany({
-                    where: { $is: { Video: {} } },
+                    where: { $is: { video: true } },
                 }),
             ).toResolveWithLength(2);
 
-            // $is: { Video: null } — null value also means "is a Video"
+            // $is: { video: { duration: { gt: 100 } } } — only v2
             await expect(
                 client.asset.findMany({
-                    where: { $is: { Video: null } },
-                }),
-            ).toResolveWithLength(2);
-
-            // $is: { Video: { duration: { gt: 100 } } } — only v2
-            await expect(
-                client.asset.findMany({
-                    where: { $is: { Video: { duration: { gt: 100 } } } },
+                    where: { $is: { video: { duration: { gt: 100 } } } },
                 }),
             ).toResolveWithLength(1);
 
             // $is combined with base-model field filter
             await expect(
                 client.asset.findMany({
-                    where: { viewCount: { gt: 0 }, $is: { Video: { duration: { gt: 100 } } } },
+                    where: { viewCount: { gt: 0 }, $is: { video: { duration: { gt: 100 } } } },
                 }),
             ).toResolveWithLength(1);
 
-            // $is: { Video: { duration: { gte: 100 } } } — both videos
+            // $is: { video: { duration: { gte: 100 } } } — both videos
             await expect(
                 client.asset.findMany({
-                    where: { $is: { Video: { duration: { gte: 100 } } } },
+                    where: { $is: { video: { duration: { gte: 100 } } } },
                 }),
             ).toResolveWithLength(2);
 
             // $is with multiple sub-models → OR semantics (1 Video with viewCount>0 OR the Image)
             await expect(
                 client.asset.findMany({
-                    where: { $is: { Video: { duration: { gt: 100 } }, Image: { format: 'png' } } },
+                    where: { $is: { video: { duration: { gt: 100 } }, image: { format: 'png' } } },
                 }),
             ).toResolveWithLength(2);
 
-            // $is on Video (which is itself a delegate) — filter on its sub-model RatedVideo
+            // $is on Video (which is itself a delegate) — filter on its sub-model ratedVideo
             await expect(
                 client.video.findMany({
-                    where: { $is: { RatedVideo: { rating: 5 } } },
+                    where: { $is: { ratedVideo: { rating: 5 } } },
                 }),
             ).toResolveWithLength(1);
 
-            // nested $is: Asset.$is.Video.$is.RatedVideo
+            // nested $is: Asset.$is.video.$is.ratedVideo
             await expect(
                 client.asset.findMany({
-                    where: { $is: { Video: { $is: { RatedVideo: { rating: 5 } } } } },
+                    where: { $is: { video: { $is: { ratedVideo: { rating: 5 } } } } },
                 }),
             ).toResolveWithLength(1);
         });