dynamo-query-engine 1.0.2 → 1.0.3

package/package.json

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

package/src/utils/validation.js

@@ -83,22 +83,65 @@ export function validateExpandField(field, gridConfig) {
 }
 
 /**
- * Validates pagination model
+ * Validates pagination model and ensures numeric types
  * @param {PaginationModel} paginationModel - Pagination model to validate
  * @throws {Error} If pagination model is invalid
+ * @returns {PaginationModel} Normalized pagination model with numeric values
  */
 export function validatePaginationModel(paginationModel) {
   if (!paginationModel) {
     throw new Error("paginationModel is required");
   }
 
-  if (!paginationModel.pageSize || paginationModel.pageSize < 1) {
+  // Check if pageSize exists first
+  if (!paginationModel.pageSize) {
     throw new Error("paginationModel.pageSize must be a positive number");
   }
 
-  if (paginationModel.pageSize > 1000) {
+  // Convert pageSize to number if it's a string
+  let pageSize = paginationModel.pageSize;
+  if (typeof pageSize === "string") {
+    pageSize = Number(pageSize);
+    if (isNaN(pageSize)) {
+      throw new Error(
+        `paginationModel.pageSize must be a valid number, received '${paginationModel.pageSize}'`
+      );
+    }
+    // Mutate the original object to ensure downstream code uses the number
+    paginationModel.pageSize = pageSize;
+  } else if (typeof pageSize !== "number") {
+    throw new Error(
+      `paginationModel.pageSize must be a number, received ${typeof pageSize}`
+    );
+  }
+
+  if (pageSize < 1) {
+    throw new Error("paginationModel.pageSize must be a positive number");
+  }
+
+  if (pageSize > 1000) {
     throw new Error(
       "paginationModel.pageSize cannot exceed 1000 (DynamoDB limit)"
     );
   }
+
+  // Convert page to number if it exists and is a string
+  if (paginationModel.page !== undefined) {
+    let page = paginationModel.page;
+    if (typeof page === "string") {
+      page = Number(page);
+      if (isNaN(page)) {
+        throw new Error(
+          `paginationModel.page must be a valid number, received '${paginationModel.page}'`
+        );
+      }
+      paginationModel.page = page;
+    } else if (typeof page !== "number") {
+      throw new Error(
+        `paginationModel.page must be a number, received ${typeof page}`
+      );
+    }
+  }
+
+  return paginationModel;
 }

package/tests/unit/validation.test.js

@@ -311,6 +311,67 @@ describe("Validation Utils", () => {
         validatePaginationModel({ pageSize: 2000 });
       }).toThrow(/DynamoDB limit/);
     });
+
+    describe("String to Number Conversion", () => {
+      it("should convert pageSize string to number", () => {
+        const paginationModel = { pageSize: "25" };
+        validatePaginationModel(paginationModel);
+        expect(paginationModel.pageSize).toBe(25);
+        expect(typeof paginationModel.pageSize).toBe("number");
+      });
+
+      it("should convert page string to number", () => {
+        const paginationModel = { pageSize: 25, page: "1" };
+        validatePaginationModel(paginationModel);
+        expect(paginationModel.page).toBe(1);
+        expect(typeof paginationModel.page).toBe("number");
+      });
+
+      it("should convert both pageSize and page strings to numbers", () => {
+        const paginationModel = { pageSize: "50", page: "2" };
+        validatePaginationModel(paginationModel);
+        expect(paginationModel.pageSize).toBe(50);
+        expect(paginationModel.page).toBe(2);
+        expect(typeof paginationModel.pageSize).toBe("number");
+        expect(typeof paginationModel.page).toBe("number");
+      });
+
+      it("should throw error for invalid pageSize string", () => {
+        expect(() => {
+          validatePaginationModel({ pageSize: "abc" });
+        }).toThrow("must be a valid number");
+      });
+
+      it("should throw error for invalid page string", () => {
+        expect(() => {
+          validatePaginationModel({ pageSize: 25, page: "invalid" });
+        }).toThrow("must be a valid number");
+      });
+
+      it("should throw error for non-string, non-number pageSize", () => {
+        expect(() => {
+          validatePaginationModel({ pageSize: true });
+        }).toThrow("must be a number");
+      });
+
+      it("should throw error for object pageSize", () => {
+        expect(() => {
+          validatePaginationModel({ pageSize: { value: 25 } });
+        }).toThrow("must be a number");
+      });
+
+      it("should validate converted string pageSize against limits", () => {
+        expect(() => {
+          validatePaginationModel({ pageSize: "1001" });
+        }).toThrow("cannot exceed 1000");
+      });
+
+      it("should validate converted string pageSize is positive", () => {
+        expect(() => {
+          validatePaginationModel({ pageSize: "0" });
+        }).toThrow("must be a positive number");
+      });
+    });
   });
 
   describe("Edge Cases", () => {