dynamo-query-engine 1.0.1 → 1.0.3

package/tests/unit/validation.test.js

@@ -0,0 +1,411 @@
+/**
+ * @fileoverview Tests for validation utilities
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  validateSingleSort,
+  validateFilterField,
+  validateSortField,
+  validateFilterOperator,
+  validateExpandField,
+  validatePaginationModel,
+} from "../../src/utils/validation.js";
+
+describe("Validation Utils", () => {
+  describe("validateSingleSort", () => {
+    it("should allow empty sort model", () => {
+      expect(() => {
+        validateSingleSort([]);
+      }).not.toThrow();
+    });
+
+    it("should allow null sort model", () => {
+      expect(() => {
+        validateSingleSort(null);
+      }).not.toThrow();
+    });
+
+    it("should allow undefined sort model", () => {
+      expect(() => {
+        validateSingleSort(undefined);
+      }).not.toThrow();
+    });
+
+    it("should allow single sort field", () => {
+      const sortModel = [{ field: "createdAt", sort: "desc" }];
+
+      expect(() => {
+        validateSingleSort(sortModel);
+      }).not.toThrow();
+    });
+
+    it("should throw error for multiple sort fields", () => {
+      const sortModel = [
+        { field: "createdAt", sort: "desc" },
+        { field: "status", sort: "asc" },
+      ];
+
+      expect(() => {
+        validateSingleSort(sortModel);
+      }).toThrow("Multiple sort fields are not allowed");
+    });
+
+    it("should mention DynamoDB limitation in error", () => {
+      const sortModel = [
+        { field: "field1", sort: "asc" },
+        { field: "field2", sort: "desc" },
+      ];
+
+      expect(() => {
+        validateSingleSort(sortModel);
+      }).toThrow(/DynamoDB/);
+    });
+  });
+
+  describe("validateFilterField", () => {
+    const gridConfig = {
+      status: {
+        filter: {
+          type: "key",
+          operators: ["eq"],
+        },
+      },
+      createdAt: {
+        filter: {
+          type: "key",
+          operators: ["gte", "lte"],
+        },
+      },
+    };
+
+    it("should allow filtering on configured field", () => {
+      expect(() => {
+        validateFilterField("status", gridConfig);
+      }).not.toThrow();
+    });
+
+    it("should throw error for non-configured field", () => {
+      expect(() => {
+        validateFilterField("name", gridConfig);
+      }).toThrow("Filtering not allowed on field 'name'");
+    });
+
+    it("should throw error for field without filter config", () => {
+      const configWithoutFilter = {
+        name: {
+          sort: { type: "key" },
+        },
+      };
+
+      expect(() => {
+        validateFilterField("name", configWithoutFilter);
+      }).toThrow("Filtering not allowed");
+    });
+
+    it("should provide helpful error message", () => {
+      expect(() => {
+        validateFilterField("invalidField", gridConfig);
+      }).toThrow(/grid\.filter config/);
+    });
+  });
+
+  describe("validateSortField", () => {
+    const gridConfig = {
+      createdAt: {
+        sort: { type: "key" },
+      },
+      updatedAt: {
+        sort: { type: "key" },
+      },
+    };
+
+    it("should allow sorting on configured field", () => {
+      expect(() => {
+        validateSortField("createdAt", gridConfig);
+      }).not.toThrow();
+    });
+
+    it("should throw error for non-configured field", () => {
+      expect(() => {
+        validateSortField("name", gridConfig);
+      }).toThrow("Sorting not allowed on field 'name'");
+    });
+
+    it("should throw error for field without sort config", () => {
+      const configWithoutSort = {
+        name: {
+          filter: { type: "key", operators: ["eq"] },
+        },
+      };
+
+      expect(() => {
+        validateSortField("name", configWithoutSort);
+      }).toThrow("Sorting not allowed");
+    });
+
+    it("should provide helpful error message", () => {
+      expect(() => {
+        validateSortField("invalidField", gridConfig);
+      }).toThrow(/grid\.sort config/);
+    });
+  });
+
+  describe("validateFilterOperator", () => {
+    const gridConfig = {
+      status: {
+        filter: {
+          type: "key",
+          operators: ["eq"],
+        },
+      },
+      createdAt: {
+        filter: {
+          type: "key",
+          operators: ["gte", "lte", "between"],
+        },
+      },
+    };
+
+    it("should allow configured operator", () => {
+      expect(() => {
+        validateFilterOperator("status", "eq", gridConfig);
+      }).not.toThrow();
+    });
+
+    it("should allow multiple configured operators", () => {
+      expect(() => {
+        validateFilterOperator("createdAt", "gte", gridConfig);
+      }).not.toThrow();
+
+      expect(() => {
+        validateFilterOperator("createdAt", "lte", gridConfig);
+      }).not.toThrow();
+
+      expect(() => {
+        validateFilterOperator("createdAt", "between", gridConfig);
+      }).not.toThrow();
+    });
+
+    it("should throw error for non-allowed operator", () => {
+      expect(() => {
+        validateFilterOperator("status", "gte", gridConfig);
+      }).toThrow("Operator 'gte' not allowed for field 'status'");
+    });
+
+    it("should throw error for field without filter config", () => {
+      expect(() => {
+        validateFilterOperator("nonexistent", "eq", gridConfig);
+      }).toThrow("does not have filter configuration");
+    });
+
+    it("should list allowed operators in error message", () => {
+      expect(() => {
+        validateFilterOperator("status", "contains", gridConfig);
+      }).toThrow(/Allowed operators: eq/);
+    });
+  });
+
+  describe("validateExpandField", () => {
+    const gridConfig = {
+      teamIds: {
+        expand: {
+          type: "Team",
+          relation: "MANY",
+          defaultLimit: 5,
+          maxLimit: 20,
+        },
+      },
+      ownerId: {
+        expand: {
+          type: "User",
+          relation: "ONE",
+          defaultLimit: 1,
+          maxLimit: 1,
+        },
+      },
+    };
+
+    it("should allow expanding configured field", () => {
+      expect(() => {
+        validateExpandField("teamIds", gridConfig);
+      }).not.toThrow();
+    });
+
+    it("should throw error for non-configured field", () => {
+      expect(() => {
+        validateExpandField("status", gridConfig);
+      }).toThrow("Expand not allowed on field 'status'");
+    });
+
+    it("should throw error for field without expand config", () => {
+      const configWithoutExpand = {
+        name: {
+          filter: { type: "key", operators: ["eq"] },
+        },
+      };
+
+      expect(() => {
+        validateExpandField("name", configWithoutExpand);
+      }).toThrow("Expand not allowed");
+    });
+
+    it("should provide helpful error message", () => {
+      expect(() => {
+        validateExpandField("invalidField", gridConfig);
+      }).toThrow(/grid\.expand config/);
+    });
+  });
+
+  describe("validatePaginationModel", () => {
+    it("should allow valid pagination model", () => {
+      expect(() => {
+        validatePaginationModel({ pageSize: 20 });
+      }).not.toThrow();
+    });
+
+    it("should allow pageSize of 1", () => {
+      expect(() => {
+        validatePaginationModel({ pageSize: 1 });
+      }).not.toThrow();
+    });
+
+    it("should allow pageSize up to 1000", () => {
+      expect(() => {
+        validatePaginationModel({ pageSize: 1000 });
+      }).not.toThrow();
+    });
+
+    it("should throw error when paginationModel is missing", () => {
+      expect(() => {
+        validatePaginationModel(null);
+      }).toThrow("paginationModel is required");
+    });
+
+    it("should throw error when pageSize is missing", () => {
+      expect(() => {
+        validatePaginationModel({});
+      }).toThrow("pageSize must be a positive number");
+    });
+
+    it("should throw error when pageSize is zero", () => {
+      expect(() => {
+        validatePaginationModel({ pageSize: 0 });
+      }).toThrow("pageSize must be a positive number");
+    });
+
+    it("should throw error when pageSize is negative", () => {
+      expect(() => {
+        validatePaginationModel({ pageSize: -5 });
+      }).toThrow("pageSize must be a positive number");
+    });
+
+    it("should throw error when pageSize exceeds 1000", () => {
+      expect(() => {
+        validatePaginationModel({ pageSize: 1001 });
+      }).toThrow("pageSize cannot exceed 1000");
+    });
+
+    it("should mention DynamoDB limit in error", () => {
+      expect(() => {
+        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", () => {
+    it("should handle empty grid config", () => {
+      const emptyConfig = {};
+
+      expect(() => {
+        validateFilterField("anyField", emptyConfig);
+      }).toThrow();
+
+      expect(() => {
+        validateSortField("anyField", emptyConfig);
+      }).toThrow();
+    });
+
+    it("should handle config with mixed field types", () => {
+      const mixedConfig = {
+        field1: {
+          filter: { type: "key", operators: ["eq"] },
+        },
+        field2: {
+          sort: { type: "key" },
+        },
+        field3: {
+          expand: { type: "Model", relation: "ONE", defaultLimit: 1, maxLimit: 1 },
+        },
+      };
+
+      expect(() => validateFilterField("field1", mixedConfig)).not.toThrow();
+      expect(() => validateSortField("field2", mixedConfig)).not.toThrow();
+      expect(() => validateExpandField("field3", mixedConfig)).not.toThrow();
+
+      expect(() => validateFilterField("field2", mixedConfig)).toThrow();
+      expect(() => validateSortField("field1", mixedConfig)).toThrow();
+    });
+  });
+});

package/vitest.config.js

@@ -0,0 +1,20 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      include: ["src/**/*.js"],
+      exclude: ["src/types/**", "examples/**", "tests/**"],
+      thresholds: {
+        lines: 50,
+        functions: 50,
+        branches: 50,
+        statements: 50,
+      },
+    },
+  },
+});