feat(db): enhance applyWhere with comprehensive documentation and robust testing

bitbeckers · bitbeckers · commit 5df0b8bdd283 · 2025-04-08T20:01:31.000+02:00
Improved the applyWhere utility with:
- Detailed JSDoc documentation explaining function purpose, type parameters, and usage
- Comprehensive test suite covering various filtering scenarios, comparison operators, and query builder integration
- Enhanced testing using pg-mem for in-memory database simulation
diff --git a/src/lib/db/queryModifiers/applyWhere.ts b/src/lib/db/queryModifiers/applyWhere.ts
@@ -8,11 +8,36 @@ import {
 } from "../../../lib/graphql/buildWhereCondition.js";
 
 /**
- * Applies where conditions to a query based on the provided arguments
- * @param tableName The name of the table to query
- * @param query The query to apply the where conditions to
- * @param args The arguments containing where conditions
+ * Applies where conditions to a query based on the provided arguments.
+ * This function processes each condition in the where clause and applies them to the query.
+ *
+ * @typeParam DB - The database type extending SupportedDatabases
+ * @typeParam T - The table name type (must be a key of DB and a string)
+ * @typeParam Args - The arguments type extending BaseQueryArgsType
+ *
+ * @param tableName - The name of the table to query
+ * @param query - The Kysely SelectQueryBuilder instance to apply where conditions to
+ * @param args - The arguments containing where conditions
+ *
  * @returns The modified query with where conditions applied
+ *
+ * @remarks
+ * - If no where conditions are provided (args.where is undefined), returns the original query
+ * - Each property in the where object is processed independently
+ * - Invalid conditions (those that return undefined from buildWhereCondition) are skipped
+ * - The conditions are applied in sequence using AND logic
+ *
+ * @example
+ * ```typescript
+ * const query = db.selectFrom('users');
+ * const args = {
+ *   where: {
+ *     name: { eq: "John" },
+ *     age: { gt: 18 }
+ *   }
+ * };
+ * const result = applyWhere('users', query, args);
+ * ```
  */
 export function applyWhere<
   DB extends SupportedDatabases,
diff --git a/src/lib/graphql/buildWhereCondition.ts b/src/lib/graphql/buildWhereCondition.ts
@@ -102,6 +102,7 @@ const isNestedFilter = (value: FilterValue): value is NestedFilterValue =>
  *
  * @type {Record<FilterOperator, FilterBuilder>}
  */
+// TODO: add support for negated filters
 const filterBuilders: Record<FilterOperator, FilterBuilder> = {
   eq: (tableName, column, value) =>
     sql<SqlBool>`${sql.raw(`"${tableName}"."${column}"`)} = ${value}`,
diff --git a/test/lib/db/queryModifiers/applyWhere.test.ts b/test/lib/db/queryModifiers/applyWhere.test.ts
@@ -1,86 +1,220 @@
-import { sql } from "kysely";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
+import { Kysely } from "kysely";
+import { IMemoryDb, newDb } from "pg-mem";
 import { applyWhere } from "../../../../src/lib/db/queryModifiers/applyWhere.js";
-import { FilterValue } from "../../../../src/lib/graphql/buildWhereCondition.js";
+import { DataDatabase } from "../../../../src/types/kyselySupabaseData.js";
 
-// Mock the buildWhereCondition function
-vi.mock("../../../../src/lib/graphql/buildWhereCondition.js", () => ({
-  buildWhereCondition: vi.fn(),
-  FilterValue: {},
-}));
-
-// Import the mocked module
-import { buildWhereCondition } from "../../../../src/lib/graphql/buildWhereCondition.js";
+type TestDatabase = DataDatabase & {
+  test_users: {
+    id: number;
+    name: string;
+    age: number;
+    active: boolean;
+    created_at: Date;
+    tags: string[];
+  };
+};
 
 describe("applyWhere", () => {
-  const mockQuery = {
-    where: vi.fn().mockReturnThis(),
-  };
+  let db: Kysely<TestDatabase>;
+  let mem: IMemoryDb;
 
-  // Reset mocks before each test
   beforeEach(() => {
-    vi.clearAllMocks();
+    mem = newDb();
+    db = mem.adapters.createKysely();
+
+    // Create test table
+    mem.public.none(`
+      CREATE TABLE test_users (
+        id SERIAL PRIMARY KEY,
+        name TEXT NOT NULL,
+        age INTEGER NOT NULL,
+        active BOOLEAN NOT NULL DEFAULT true,
+        created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+        tags TEXT[] NOT NULL DEFAULT '{}'
+      );
+    `);
+  });
+
+  describe("basic functionality", () => {
+    it("should return original query when no where clause is provided", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {},
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).not.toContain("where");
+      expect(parameters).toEqual([]);
+    });
+
+    it("should apply simple equality condition", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: { name: { eq: "John" } },
+        },
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).toMatch(/where.*"test_users"."name".*=.*\$1/i);
+      expect(parameters).toEqual(["John"]);
+    });
+
+    it("should apply multiple conditions with AND", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: {
+            name: { eq: "John" },
+            age: { gt: 18 },
+          },
+        },
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).toMatch(
+        /where.*"test_users"."name".*=.*\$1.*and.*"test_users"."age".*>.*\$2/i,
+      );
+      expect(parameters).toEqual(["John", 18]);
+    });
+  });
+
+  describe("comparison operators", () => {
+    it("should handle greater than condition", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: { age: { gt: 18 } },
+        },
+      );
 
-    // Default implementation for buildWhereCondition
-    vi.mocked(buildWhereCondition).mockImplementation((tableName, where) => {
-      // Simple mock implementation that returns a SQL condition for testing
-      const column = Object.keys(where)[0];
-      return sql`${sql.raw(`"${tableName}"."${column}"`)} = 'test'`;
+      const { sql, parameters } = result.compile();
+      expect(sql).toMatch(/where.*"test_users"."age".*>.*\$1/i);
+      expect(parameters).toEqual([18]);
+    });
+
+    it("should handle less than or equal condition", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: { age: { lte: 65 } },
+        },
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).toMatch(/where.*"test_users"."age".*<=.*\$1/i);
+      expect(parameters).toEqual([65]);
     });
   });
 
-  it("should return the original query if where is not provided", () => {
-    const args = { first: 10, offset: 0 };
-    const result = applyWhere<any, any, any>(
-      "test_table" as any,
-      mockQuery as any,
-      args,
-    );
+  describe("text search conditions", () => {
+    it("should handle contains condition", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: { name: { contains: "oh" } },
+        },
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).toMatch(
+        /where.*lower.*"test_users"."name".*like.*lower.*\$1/i,
+      );
+      expect(parameters).toEqual(["%oh%"]);
+    });
+
+    it("should handle startsWith condition", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: { name: { startsWith: "Jo" } },
+        },
+      );
 
-    expect(result).toBe(mockQuery);
-    expect(mockQuery.where).not.toHaveBeenCalled();
+      const { sql, parameters } = result.compile();
+      expect(sql).toMatch(
+        /where.*lower.*"test_users"."name".*like.*lower.*\$1/i,
+      );
+      expect(parameters).toEqual(["Jo%"]);
+    });
   });
 
-  it("should apply where conditions for each property in the where object", () => {
-    const args = {
-      first: 10,
-      offset: 0,
-      where: {
-        name: { eq: "test" } as FilterValue,
-        age: { gt: 18 } as FilterValue,
-      },
-    };
-
-    const result = applyWhere<any, any, any>(
-      "test_table" as any,
-      mockQuery as any,
-      args,
-    );
-
-    expect(result).toBe(mockQuery);
-    expect(mockQuery.where).toHaveBeenCalledTimes(2);
+  describe("array conditions", () => {
+    it("should handle array contains condition", () => {
+      const baseQuery = db.selectFrom("test_users").selectAll() as any;
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: { tags: { arrayContains: ["tag1", "tag2"] } },
+        },
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).toMatch(/where.*"test_users"."tags".*@>.*array\[\$1, \$2\]/i);
+      expect(parameters).toEqual(["tag1", "tag2"]);
+    });
   });
 
-  it("should skip properties that don't generate a valid condition", () => {
-    // Mock buildWhereCondition to return undefined for the first call
-    vi.mocked(buildWhereCondition).mockImplementationOnce(() => undefined);
-
-    const args = {
-      first: 10,
-      offset: 0,
-      where: {
-        invalid: { eq: "test" } as FilterValue,
-        valid: { eq: "test" } as FilterValue,
-      },
-    };
-
-    const result = applyWhere<any, any, any>(
-      "test_table" as any,
-      mockQuery as any,
-      args,
-    );
-
-    expect(result).toBe(mockQuery);
-    expect(mockQuery.where).toHaveBeenCalledTimes(1);
+  describe("query builder integration", () => {
+    it("should work with complex queries", () => {
+      const baseQuery = db
+        .selectFrom("test_users")
+        .selectAll()
+        .orderBy("created_at") as any;
+
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: {
+            active: { eq: true },
+            age: { gt: 18 },
+          },
+        },
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).toContain("where");
+      expect(sql).toContain("order by");
+      expect(parameters).toEqual([true, 18]);
+    });
+
+    it("should preserve existing query modifiers", () => {
+      const baseQuery = db
+        .selectFrom("test_users")
+        .selectAll()
+        .orderBy("created_at")
+        .limit(10) as any;
+
+      const result = applyWhere<TestDatabase, "test_users", any>(
+        "test_users",
+        baseQuery,
+        {
+          where: { active: { eq: true } },
+        },
+      );
+
+      const { sql, parameters } = result.compile();
+      expect(sql).toContain("where");
+      expect(sql).toContain("order by");
+      expect(sql).toContain("limit");
+      expect(parameters).toEqual([true, 10]);
+    });
   });
 });

Original file line number	Diff line number	Diff line change
`@@ -102,6 +102,7 @@ const isNestedFilter = (value: FilterValue): value is NestedFilterValue =>`
`102`	`102`	`*`
`103`	`103`	`* @type {Record<FilterOperator, FilterBuilder>}`
`104`	`104`	`*/`
	`105`	`+// TODO: add support for negated filters`
`105`	`106`	`const filterBuilders: Record<FilterOperator, FilterBuilder> = {`
`106`	`107`	`eq: (tableName, column, value) =>`
`107`	`108`	sql<SqlBool>`${sql.raw(`"${tableName}"."${column}"`)} = ${value}`,