dynamo-query-engine 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamo-query-engine",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Type-safe DynamoDB query builder for GraphQL with support for filtering, sorting, pagination, and relation expansion",
   "type": "module",
   "main": "index.js",

package/src/core/expandResolver.js

@@ -4,9 +4,7 @@
 
 import "../types/jsdoc.js";
 import { modelRegistry } from "./modelRegistry.js";
-import { buildGridQuery } from "./gridQueryBuilder.js";
-import { validateExpandField } from "../utils/validation.js";
-import { extractGridConfig } from "./gridQueryBuilder.js";
+import { buildGridQuery, extractGridConfig } from "./gridQueryBuilder.js";
 
 /**
  * Extract expand policy from schema
@@ -62,6 +60,15 @@ export async function resolveExpand({
   // Get target model from registry
   const targetModel = modelRegistry.get(policy.type);
 
+  // Get the GraphQL type name from the schema (if defined)
+  const attributes = parentModel.schema.getAttributes();
+  const fieldConfig = attributes[field];
+  const graphqlTypeName = fieldConfig?.graphql?.type || policy.type;
+  
+  // Determine which property name to use for storing the expanded data
+  // If graphql.type is defined, use it as the property name, otherwise use the field name
+  const expandPropertyName = fieldConfig?.graphql?.type || field;
+
   // Determine limit based on args and policy
   const requestedLimit = args.pagination?.pageSize ?? policy.defaultLimit;
   const limit = Math.min(requestedLimit, policy.maxLimit);
@@ -77,7 +84,7 @@ export async function resolveExpand({
         console.warn(
           `Cannot expand '${field}' for parent: missing partition key value`
         );
-        parent[field] = [];
+        parent[expandPropertyName] = [];
         return;
       }
 
@@ -94,16 +101,22 @@ export async function resolveExpand({
       // Execute query
       const results = await query.exec();
 
+      // Add __typename to each result
+      const resultsWithTypename = results.map((item) => ({
+        ...item,
+        __typename: graphqlTypeName,
+      }));
+
       // Assign results to parent
       if (policy.relation === "ONE") {
-        parent[field] = results.length > 0 ? results[0] : null;
+        parent[expandPropertyName] = resultsWithTypename.length > 0 ? resultsWithTypename[0] : null;
       } else {
-        parent[field] = results;
+        parent[expandPropertyName] = resultsWithTypename;
       }
     } catch (error) {
       console.error(`Error expanding '${field}' for parent:`, error);
       // Gracefully handle errors - set empty result
-      parent[field] = policy.relation === "ONE" ? null : [];
+      parent[expandPropertyName] = policy.relation === "ONE" ? null : [];
     }
   });
 
@@ -111,6 +124,27 @@ export async function resolveExpand({
   await Promise.all(expandPromises);
 }
 
+/**
+ * Create a mapping from GraphQL field names to schema field names
+ * @param {*} schema - Dynamoose schema
+ * @returns {Object.<string, string>} Map of GraphQL field name to schema field name
+ */
+function createGraphQLToSchemaFieldMap(schema) {
+  const attributes = schema.getAttributes();
+  const map = {};
+
+  for (const [fieldName, config] of Object.entries(attributes)) {
+    // If the field has a graphql.type config, map from graphql type to field name
+    if (config?.graphql?.type) {
+      map[config.graphql.type] = fieldName;
+    }
+    // Also keep the original field name mapping (for backward compatibility)
+    map[fieldName] = fieldName;
+  }
+
+  return map;
+}
+
 /**
  * Resolve multiple expands from GraphQL resolve info
  * @param {Array} parentItems - Parent items to expand
@@ -137,18 +171,29 @@ export async function resolveExpands(
 
   // Get expand policy to filter only expandable fields
   const expandPolicy = extractExpandPolicy(parentModel.schema);
+  
+  // Create mapping from GraphQL field names to schema field names
+  const graphqlToSchemaMap = createGraphQLToSchemaFieldMap(parentModel.schema);
 
   // Resolve all expands in parallel
   const expandPromises = Object.entries(fields)
-    .filter(([fieldName]) => expandPolicy[fieldName])
-    .map(([fieldName, fieldInfo]) =>
-      resolveExpand({
+    .map(([graphqlFieldName, fieldInfo]) => {
+      // Map GraphQL field name to schema field name
+      const schemaFieldName = graphqlToSchemaMap[graphqlFieldName];
+      
+      // Check if this field is expandable
+      if (!schemaFieldName || !expandPolicy[schemaFieldName]) {
+        return null;
+      }
+
+      return resolveExpand({
         parentItems,
         parentModel,
-        field: fieldName,
+        field: schemaFieldName,
         args: fieldInfo.args || {},
-      })
-    );
+      });
+    })
+    .filter(Boolean); // Remove null entries
 
   await Promise.all(expandPromises);
 }

package/src/core/gridQueryBuilder.js

@@ -9,7 +9,6 @@ import {
   validateFilterField,
   validateSortField,
   validateFilterOperator,
-  validatePaginationModel,
 } from "../utils/validation.js";
 import { decodeCursor, validateCursor } from "../utils/cursor.js";
 
@@ -18,13 +17,13 @@ import { decodeCursor, validateCursor } from "../utils/cursor.js";
  * @param {Object} params - Query parameters
  * @param {FilterModel} params.filterModel - Filter model
  * @param {SortModel} params.sortModel - Sort model
- * @param {number} params.pageSize - Page size
+ * @param {number} params.limit - Query limit
  * @returns {string} SHA256 hash of the query parameters
  */
-function hashQuery({ filterModel, sortModel, pageSize }) {
+function hashQuery({ filterModel, sortModel, limit }) {
   return crypto
     .createHash("sha256")
-    .update(JSON.stringify({ filterModel, sortModel, pageSize }))
+    .update(JSON.stringify({ filterModel, sortModel, limit }))
     .digest("hex");
 }
 
@@ -199,7 +198,7 @@ export function buildGridQuery({
   partitionKeyValue,
   filterModel,
   sortModel,
-  paginationModel,
+  limit = 10,
   cursor,
 }) {
   // Validate inputs
@@ -209,7 +208,21 @@ export function buildGridQuery({
   if (!partitionKeyValue) {
     throw new Error("partitionKeyValue is required");
   }
-  validatePaginationModel(paginationModel);
+  
+  // Validate and normalize limit
+  if (limit !== undefined && limit !== null) {
+    const numLimit = typeof limit === "string" ? Number(limit) : limit;
+    if (Number.isNaN(numLimit) || numLimit < 1) {
+      throw new Error("limit must be a positive number");
+    }
+    if (numLimit > 1000) {
+      throw new Error("limit cannot exceed 1000 (DynamoDB limit)");
+    }
+    limit = numLimit;
+  } else {
+    limit = 10;
+  }
+  
   validateSingleSort(sortModel);
 
   // Extract grid config from schema
@@ -225,7 +238,7 @@ export function buildGridQuery({
   const queryHash = hashQuery({
     filterModel,
     sortModel,
-    pageSize: paginationModel.pageSize,
+    limit,
   });
 
   // Initialize query with partition key
@@ -242,8 +255,8 @@ export function buildGridQuery({
   // Apply sort
   query = applySort(query, sortModel, gridConfig);
 
-  // Apply pagination limit
-  query = query.limit(paginationModel.pageSize);
+  // Apply limit
+  query = query.limit(limit);
 
   // Handle cursor for pagination
   if (cursor) {

package/tests/unit/expandResolver.test.js

@@ -0,0 +1,339 @@
+/**
+ * @fileoverview Tests for expand resolver with GraphQL type names
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { resolveExpand, resolveExpands } from "../../src/core/expandResolver.js";
+import { modelRegistry } from "../../src/core/modelRegistry.js";
+import { createMockSchema, createMockModel, createMockQuery } from "../mocks/dynamoose.mock.js";
+
+describe("ExpandResolver", () => {
+  describe("resolveExpand with GraphQL type names", () => {
+    let parentModel;
+    let targetModel;
+    let parentItems;
+
+    beforeEach(() => {
+      // Clear registry
+      modelRegistry.clear();
+
+      // Create parent schema with unitId field that has graphql.type config
+      const parentSchema = createMockSchema({
+        tenantId: {
+          type: String,
+          hashKey: true,
+        },
+        reservationId: {
+          type: String,
+          rangeKey: true,
+        },
+        unitId: {
+          type: String,
+          query: {
+            expand: {
+              type: "Unit",
+              relation: "ONE",
+              defaultLimit: 1,
+              maxLimit: 1,
+            },
+          },
+          graphql: {
+            type: "Unit", // GraphQL type name
+          },
+        },
+      });
+
+      // Create target schema (Unit)
+      const targetSchema = createMockSchema({
+        tenantId: {
+          type: String,
+          hashKey: true,
+        },
+        unitId: {
+          type: String,
+          rangeKey: true,
+        },
+        name: {
+          type: String,
+        },
+      });
+
+      // Create parent model
+      parentModel = createMockModel(parentSchema);
+
+      // Create target model with mock query result
+      const unitData = [
+        {
+          tenantId: "tenant-1",
+          unitId: "unit-1",
+          name: "Unit A",
+        },
+      ];
+      targetModel = createMockModel(targetSchema, unitData);
+
+      // Register target model
+      modelRegistry.register("Unit", targetModel);
+
+      // Create parent items
+      parentItems = [
+        {
+          tenantId: "tenant-1",
+          reservationId: "res-1",
+          unitId: "unit-1",
+        },
+      ];
+    });
+
+    it("should store expanded data under GraphQL type name (Unit) not field name (unitId)", async () => {
+      await resolveExpand({
+        parentItems,
+        parentModel,
+        field: "unitId",
+      });
+
+      // The expanded data should be under 'Unit', not 'unitId'
+      expect(parentItems[0].Unit).toBeDefined();
+      expect(parentItems[0].Unit).toEqual({
+        tenantId: "tenant-1",
+        unitId: "unit-1",
+        name: "Unit A",
+        __typename: "Unit",
+      });
+    });
+
+    it("should add __typename field to expanded data", async () => {
+      await resolveExpand({
+        parentItems,
+        parentModel,
+        field: "unitId",
+      });
+
+      expect(parentItems[0].Unit.__typename).toBe("Unit");
+    });
+
+    it("should handle ONE relation correctly", async () => {
+      await resolveExpand({
+        parentItems,
+        parentModel,
+        field: "unitId",
+      });
+
+      // ONE relation should return a single object, not an array
+      expect(parentItems[0].Unit).toBeDefined();
+      expect(Array.isArray(parentItems[0].Unit)).toBe(false);
+    });
+
+    it("should handle MANY relation correctly", async () => {
+      // Clear and re-register with different config
+      modelRegistry.clear();
+      
+      // Update parent schema for MANY relation
+      const parentSchemaMany = createMockSchema({
+        tenantId: {
+          type: String,
+          hashKey: true,
+        },
+        reservationId: {
+          type: String,
+          rangeKey: true,
+        },
+        unitId: {
+          type: String,
+          query: {
+            expand: {
+              type: "Unit",
+              relation: "MANY",
+              defaultLimit: 10,
+              maxLimit: 100,
+            },
+          },
+          graphql: {
+            type: "Units", // Plural for MANY relation
+          },
+        },
+      });
+
+      const unitsData = [
+        { tenantId: "tenant-1", unitId: "unit-1", name: "Unit A" },
+        { tenantId: "tenant-1", unitId: "unit-2", name: "Unit B" },
+      ];
+
+      const parentModelMany = createMockModel(parentSchemaMany);
+      const targetModelMany = createMockModel(targetModel.schema, unitsData);
+
+      modelRegistry.register("Unit", targetModelMany);
+
+      await resolveExpand({
+        parentItems,
+        parentModel: parentModelMany,
+        field: "unitId",
+      });
+
+      // MANY relation should return an array
+      expect(parentItems[0].Units).toBeDefined();
+      expect(Array.isArray(parentItems[0].Units)).toBe(true);
+      expect(parentItems[0].Units).toHaveLength(2);
+      expect(parentItems[0].Units[0].__typename).toBe("Units");
+      expect(parentItems[0].Units[1].__typename).toBe("Units");
+    });
+
+    it("should fallback to field name when graphql.type is not defined", async () => {
+      // Clear and re-register with different config
+      modelRegistry.clear();
+      
+      // Create schema without graphql.type config
+      const parentSchemaNoGraphQL = createMockSchema({
+        tenantId: {
+          type: String,
+          hashKey: true,
+        },
+        reservationId: {
+          type: String,
+          rangeKey: true,
+        },
+        unitId: {
+          type: String,
+          query: {
+            expand: {
+              type: "Unit",
+              relation: "ONE",
+              defaultLimit: 1,
+              maxLimit: 1,
+            },
+          },
+          // No graphql config
+        },
+      });
+
+      const unitData = [
+        { tenantId: "tenant-1", unitId: "unit-1", name: "Unit A" },
+      ];
+
+      const parentModelNoGraphQL = createMockModel(parentSchemaNoGraphQL);
+      const targetModelNoGraphQL = createMockModel(targetModel.schema, unitData);
+
+      modelRegistry.register("Unit", targetModelNoGraphQL);
+
+      await resolveExpand({
+        parentItems,
+        parentModel: parentModelNoGraphQL,
+        field: "unitId",
+      });
+
+      // Should fallback to field name 'unitId'
+      expect(parentItems[0].unitId).toBeDefined();
+      expect(parentItems[0].unitId.__typename).toBe("Unit");
+    });
+  });
+
+  describe("resolveExpands with GraphQL field mapping", () => {
+    let parentModel;
+    let targetModel;
+    let parentItems;
+
+    beforeEach(() => {
+      modelRegistry.clear();
+
+      const parentSchema = createMockSchema({
+        tenantId: {
+          type: String,
+          hashKey: true,
+        },
+        reservationId: {
+          type: String,
+          rangeKey: true,
+        },
+        unitId: {
+          type: String,
+          query: {
+            expand: {
+              type: "Unit",
+              relation: "ONE",
+              defaultLimit: 1,
+              maxLimit: 1,
+            },
+          },
+          graphql: {
+            type: "Unit",
+          },
+        },
+      });
+
+      const targetSchema = createMockSchema({
+        tenantId: {
+          type: String,
+          hashKey: true,
+        },
+        unitId: {
+          type: String,
+          rangeKey: true,
+        },
+        name: {
+          type: String,
+        },
+      });
+
+      const unitData = [
+        { tenantId: "tenant-1", unitId: "unit-1", name: "Unit A" },
+      ];
+
+      parentModel = createMockModel(parentSchema);
+      targetModel = createMockModel(targetSchema, unitData);
+
+      modelRegistry.register("Unit", targetModel);
+
+      parentItems = [
+        {
+          tenantId: "tenant-1",
+          reservationId: "res-1",
+          unitId: "unit-1",
+        },
+      ];
+    });
+
+    it("should map GraphQL field name (Unit) to schema field name (unitId)", async () => {
+      // Simulate GraphQL resolve info with field name 'Unit'
+      const fieldsByTypeName = {
+        Reservation: {
+          Unit: {
+            // GraphQL field name
+            fieldsByTypeName: {
+              Unit: {
+                unitId: {},
+                name: {},
+              },
+            },
+          },
+        },
+      };
+
+      await resolveExpands(parentItems, parentModel, fieldsByTypeName);
+
+      // Should map 'Unit' -> 'unitId' and store result under 'Unit'
+      expect(parentItems[0].Unit).toBeDefined();
+      expect(parentItems[0].Unit.__typename).toBe("Unit");
+    });
+
+    it("should skip non-expandable fields", async () => {
+      const fieldsByTypeName = {
+        Reservation: {
+          reservationId: {}, // Not an expandable field
+          Unit: {
+            fieldsByTypeName: {
+              Unit: {
+                unitId: {},
+                name: {},
+              },
+            },
+          },
+        },
+      };
+
+      await resolveExpands(parentItems, parentModel, fieldsByTypeName);
+
+      // Only Unit should be expanded
+      expect(parentItems[0].Unit).toBeDefined();
+      expect(parentItems[0].reservationId).toBe("res-1"); // Original value unchanged
+    });
+  });
+});

package/tests/unit/gridQueryBuilder.test.js

@@ -189,7 +189,7 @@ describe("GridQueryBuilder", () => {
       const { query } = buildGridQuery({
         model: mockModel,
         partitionKeyValue: "ORG#123",
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       expect(mockModel.query).toHaveBeenCalledWith("pk");
@@ -203,7 +203,7 @@ describe("GridQueryBuilder", () => {
         buildGridQuery({
           model: null,
           partitionKeyValue: "ORG#123",
-          paginationModel: { pageSize: 20 },
+          limit: 20,
         });
       }).toThrow("model is required");
     });
@@ -213,18 +213,19 @@ describe("GridQueryBuilder", () => {
         buildGridQuery({
           model: mockModel,
           partitionKeyValue: null,
-          paginationModel: { pageSize: 20 },
+          limit: 20,
         });
       }).toThrow("partitionKeyValue is required");
     });
 
-    it("should throw error when paginationModel is missing", () => {
-      expect(() => {
-        buildGridQuery({
-          model: mockModel,
-          partitionKeyValue: "ORG#123",
-        });
-      }).toThrow("paginationModel is required");
+    it("should use default limit when not provided", () => {
+      const { query } = buildGridQuery({
+        model: mockModel,
+        partitionKeyValue: "ORG#123",
+      });
+
+      expect(mockQuery.limit).toHaveBeenCalledWith(10);
+      expect(query).toBe(mockQuery);
     });
 
     it("should use custom hash key name from schema", () => {
@@ -248,7 +249,7 @@ describe("GridQueryBuilder", () => {
       buildGridQuery({
         model: customMockModel,
         partitionKeyValue: "tenant-123",
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       // Should query with 'tenantId' not 'pk'
@@ -277,7 +278,7 @@ describe("GridQueryBuilder", () => {
         model: mockModel,
         partitionKeyValue: "ORG#123",
         filterModel,
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       expect(mockQuery.where).toHaveBeenCalledWith("status");
@@ -295,7 +296,7 @@ describe("GridQueryBuilder", () => {
         model: mockModel,
         partitionKeyValue: "ORG#123",
         filterModel,
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       expect(mockQuery.where).toHaveBeenCalledWith("createdAt");
@@ -317,7 +318,7 @@ describe("GridQueryBuilder", () => {
         model: mockModel,
         partitionKeyValue: "ORG#123",
         filterModel,
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       expect(mockQuery.between).toHaveBeenCalledWith("2024-01-01", "2024-12-31");
@@ -332,7 +333,7 @@ describe("GridQueryBuilder", () => {
         model: mockModel,
         partitionKeyValue: "ORG#123",
         filterModel,
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       expect(mockQuery.using).toHaveBeenCalledWith("status-createdAt-index");
@@ -348,7 +349,7 @@ describe("GridQueryBuilder", () => {
           model: mockModel,
           partitionKeyValue: "ORG#123",
           filterModel,
-          paginationModel: { pageSize: 20 },
+          limit: 20,
         });
       }).toThrow("Filtering not allowed");
     });
@@ -363,7 +364,7 @@ describe("GridQueryBuilder", () => {
           model: mockModel,
           partitionKeyValue: "ORG#123",
           filterModel,
-          paginationModel: { pageSize: 20 },
+          limit: 20,
         });
       }).toThrow("not allowed");
     });
@@ -387,7 +388,7 @@ describe("GridQueryBuilder", () => {
         model: mockModel,
         partitionKeyValue: "ORG#123",
         sortModel,
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       expect(mockQuery.sort).toHaveBeenCalledWith("descending");
@@ -400,7 +401,7 @@ describe("GridQueryBuilder", () => {
         model: mockModel,
         partitionKeyValue: "ORG#123",
         sortModel,
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       // Ascending is default, so sort() should not be called
@@ -418,7 +419,7 @@ describe("GridQueryBuilder", () => {
           model: mockModel,
           partitionKeyValue: "ORG#123",
           sortModel,
-          paginationModel: { pageSize: 20 },
+          limit: 20,
         });
       }).toThrow(/sorting by one field/);
     });
@@ -431,13 +432,13 @@ describe("GridQueryBuilder", () => {
           model: mockModel,
           partitionKeyValue: "ORG#123",
           sortModel,
-          paginationModel: { pageSize: 20 },
+          limit: 20,
         });
       }).toThrow("Sorting not allowed");
     });
   });
 
-  describe("buildGridQuery - Pagination", () => {
+  describe("buildGridQuery - Limit and Cursor", () => {
     let mockModel;
     let mockQuery;
 
@@ -448,11 +449,11 @@ describe("GridQueryBuilder", () => {
       mockModel.query = vi.fn(() => mockQuery);
     });
 
-    it("should apply page size limit", () => {
+    it("should apply limit", () => {
       buildGridQuery({
         model: mockModel,
         partitionKeyValue: "ORG#123",
-        paginationModel: { pageSize: 50 },
+        limit: 50,
       });
 
       expect(mockQuery.limit).toHaveBeenCalledWith(50);
@@ -465,7 +466,7 @@ describe("GridQueryBuilder", () => {
       const firstResult = buildGridQuery({
         model: mockModel,
         partitionKeyValue: "ORG#123",
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       // Create cursor with the actual queryHash
@@ -477,7 +478,7 @@ describe("GridQueryBuilder", () => {
       buildGridQuery({
         model: mockModel,
         partitionKeyValue: "ORG#123",
-        paginationModel: { pageSize: 20 },
+        limit: 20,
         cursor,
       });
 
@@ -496,7 +497,7 @@ describe("GridQueryBuilder", () => {
         buildGridQuery({
           model: mockModel,
           partitionKeyValue: "ORG#123",
-          paginationModel: { pageSize: 50 }, // Different page size
+          limit: 50, // Different limit
           cursor,
         });
       }).toThrow("Cursor does not match");
@@ -519,7 +520,7 @@ describe("GridQueryBuilder", () => {
           items: [{ field: "status", operator: "eq", value: "active" }],
         },
         sortModel: [{ field: "createdAt", sort: "desc" }],
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       };
 
       const result1 = buildGridQuery(params);
@@ -532,7 +533,7 @@ describe("GridQueryBuilder", () => {
       const baseParams = {
         model: mockModel,
         partitionKeyValue: "ORG#123",
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       };
 
       const result1 = buildGridQuery({
@@ -552,7 +553,7 @@ describe("GridQueryBuilder", () => {
       expect(result1.queryHash).not.toBe(result2.queryHash);
     });
 
-    it("should return different hash when page size changes", () => {
+    it("should return different hash when limit changes", () => {
       const baseParams = {
         model: mockModel,
         partitionKeyValue: "ORG#123",
@@ -560,12 +561,12 @@ describe("GridQueryBuilder", () => {
 
       const result1 = buildGridQuery({
         ...baseParams,
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       const result2 = buildGridQuery({
         ...baseParams,
-        paginationModel: { pageSize: 50 },
+        limit: 50,
       });
 
       expect(result1.queryHash).not.toBe(result2.queryHash);
@@ -583,7 +584,7 @@ describe("GridQueryBuilder", () => {
       mockModel.query = vi.fn(() => mockQuery);
     });
 
-    it("should handle query with filter, sort, and pagination", () => {
+    it("should handle query with filter, sort, and limit", () => {
       buildGridQuery({
         model: mockModel,
         partitionKeyValue: "ORG#123",
@@ -591,7 +592,7 @@ describe("GridQueryBuilder", () => {
           items: [{ field: "status", operator: "eq", value: "active" }],
         },
         sortModel: [{ field: "createdAt", sort: "desc" }],
-        paginationModel: { pageSize: 25 },
+        limit: 25,
       });
 
       // Verify all operations were applied
@@ -609,7 +610,7 @@ describe("GridQueryBuilder", () => {
         partitionKeyValue: "ORG#123",
         filterModel: { items: [] },
         sortModel: [],
-        paginationModel: { pageSize: 20 },
+        limit: 20,
       });
 
       expect(query).toBeDefined();