@geekmidas/studio 0.1.0 → 0.4.0

package/src/data/__tests__/filtering.integration.spec.ts

@@ -1,741 +1,741 @@
 import {
-  CamelCasePlugin,
-  type Generated,
-  Kysely,
-  PostgresDialect,
-  sql,
+	CamelCasePlugin,
+	type Generated,
+	Kysely,
+	PostgresDialect,
+	sql,
 } from 'kysely';
 import pg from 'pg';
 import {
-  afterAll,
-  afterEach,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  it,
+	afterAll,
+	afterEach,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
 } from 'vitest';
 import { TEST_DATABASE_CONFIG } from '../../../../testkit/test/globalSetup';
 import {
-  type ColumnInfo,
-  Direction,
-  FilterOperator,
-  type TableInfo,
+	type ColumnInfo,
+	Direction,
+	FilterOperator,
+	type TableInfo,
 } from '../../types';
 import { applyFilters, applySorting, validateFilter } from '../filtering';
 
 interface TestDatabase {
-  studioFilterProducts: {
-    id: Generated<number>;
-    name: string;
-    price: number;
-    category: string;
-    inStock: boolean;
-    rating: number | null;
-    createdAt: Generated<Date>;
-  };
+	studioFilterProducts: {
+		id: Generated<number>;
+		name: string;
+		price: number;
+		category: string;
+		inStock: boolean;
+		rating: number | null;
+		createdAt: Generated<Date>;
+	};
 }
 
 describe('Filtering Integration Tests', () => {
-  let db: Kysely<TestDatabase>;
-
-  // Table info mock that matches our real table
-  const productsTableInfo: TableInfo = {
-    name: 'studio_filter_products',
-    schema: 'public',
-    columns: [
-      {
-        name: 'id',
-        type: 'number',
-        rawType: 'int4',
-        nullable: false,
-        isPrimaryKey: true,
-        isForeignKey: false,
-      },
-      {
-        name: 'name',
-        type: 'string',
-        rawType: 'varchar',
-        nullable: false,
-        isPrimaryKey: false,
-        isForeignKey: false,
-      },
-      {
-        name: 'price',
-        type: 'number',
-        rawType: 'numeric',
-        nullable: false,
-        isPrimaryKey: false,
-        isForeignKey: false,
-      },
-      {
-        name: 'category',
-        type: 'string',
-        rawType: 'varchar',
-        nullable: false,
-        isPrimaryKey: false,
-        isForeignKey: false,
-      },
-      {
-        name: 'in_stock',
-        type: 'boolean',
-        rawType: 'bool',
-        nullable: false,
-        isPrimaryKey: false,
-        isForeignKey: false,
-      },
-      {
-        name: 'rating',
-        type: 'number',
-        rawType: 'numeric',
-        nullable: true,
-        isPrimaryKey: false,
-        isForeignKey: false,
-      },
-      {
-        name: 'created_at',
-        type: 'datetime',
-        rawType: 'timestamptz',
-        nullable: false,
-        isPrimaryKey: false,
-        isForeignKey: false,
-      },
-    ],
-    primaryKey: ['id'],
-  };
-
-  beforeAll(async () => {
-    db = new Kysely<TestDatabase>({
-      dialect: new PostgresDialect({
-        pool: new pg.Pool({
-          ...TEST_DATABASE_CONFIG,
-          database: 'postgres',
-        }),
-      }),
-      plugins: [new CamelCasePlugin()],
-    });
-
-    // Create products table
-    await db.schema
-      .createTable('studio_filter_products')
-      .ifNotExists()
-      .addColumn('id', 'serial', (col) => col.primaryKey())
-      .addColumn('name', 'varchar(255)', (col) => col.notNull())
-      .addColumn('price', 'numeric(10, 2)', (col) => col.notNull())
-      .addColumn('category', 'varchar(100)', (col) => col.notNull())
-      .addColumn('in_stock', 'boolean', (col) => col.notNull().defaultTo(true))
-      .addColumn('rating', 'numeric(3, 2)')
-      .addColumn('created_at', 'timestamptz', (col) =>
-        col.defaultTo(sql`now()`).notNull(),
-      )
-      .execute();
-  });
-
-  beforeEach(async () => {
-    // Insert test data
-    await db
-      .insertInto('studioFilterProducts')
-      .values([
-        {
-          name: 'Laptop Pro',
-          price: 1299.99,
-          category: 'electronics',
-          inStock: true,
-          rating: 4.5,
-        },
-        {
-          name: 'Laptop Basic',
-          price: 599.99,
-          category: 'electronics',
-          inStock: true,
-          rating: 3.8,
-        },
-        {
-          name: 'Wireless Mouse',
-          price: 49.99,
-          category: 'electronics',
-          inStock: false,
-          rating: 4.2,
-        },
-        {
-          name: 'Office Chair',
-          price: 299.99,
-          category: 'furniture',
-          inStock: true,
-          rating: 4.0,
-        },
-        {
-          name: 'Standing Desk',
-          price: 549.99,
-          category: 'furniture',
-          inStock: true,
-          rating: null,
-        },
-        {
-          name: 'Notebook',
-          price: 9.99,
-          category: 'office',
-          inStock: true,
-          rating: 3.5,
-        },
-        {
-          name: 'Pen Set',
-          price: 19.99,
-          category: 'office',
-          inStock: false,
-          rating: 4.8,
-        },
-      ])
-      .execute();
-  });
-
-  afterEach(async () => {
-    await db.deleteFrom('studioFilterProducts').execute();
-  });
-
-  afterAll(async () => {
-    await db.schema.dropTable('studio_filter_products').ifExists().execute();
-    await db.destroy();
-  });
-
-  describe('validateFilter', () => {
-    it('should validate compatible operators for string columns', () => {
-      const nameColumn: ColumnInfo = productsTableInfo.columns.find(
-        (c) => c.name === 'name',
-      )!;
-
-      expect(
-        validateFilter(
-          { column: 'name', operator: FilterOperator.Eq, value: 'test' },
-          nameColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'name', operator: FilterOperator.Like, value: '%test%' },
-          nameColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'name', operator: FilterOperator.Ilike, value: '%TEST%' },
-          nameColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'name', operator: FilterOperator.In, value: ['a', 'b'] },
-          nameColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'name', operator: FilterOperator.IsNull },
-          nameColumn,
-        ).valid,
-      ).toBe(true);
-    });
-
-    it('should reject incompatible operators for string columns', () => {
-      const nameColumn: ColumnInfo = productsTableInfo.columns.find(
-        (c) => c.name === 'name',
-      )!;
-
-      const result = validateFilter(
-        { column: 'name', operator: FilterOperator.Gt, value: 'test' },
-        nameColumn,
-      );
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain(
-        "Operator 'gt' not supported for column type 'string'",
-      );
-    });
-
-    it('should validate compatible operators for number columns', () => {
-      const priceColumn: ColumnInfo = productsTableInfo.columns.find(
-        (c) => c.name === 'price',
-      )!;
-
-      expect(
-        validateFilter(
-          { column: 'price', operator: FilterOperator.Eq, value: 100 },
-          priceColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'price', operator: FilterOperator.Gt, value: 100 },
-          priceColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'price', operator: FilterOperator.Gte, value: 100 },
-          priceColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'price', operator: FilterOperator.Lt, value: 100 },
-          priceColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'price', operator: FilterOperator.Lte, value: 100 },
-          priceColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'price', operator: FilterOperator.In, value: [100, 200] },
-          priceColumn,
-        ).valid,
-      ).toBe(true);
-    });
-
-    it('should reject incompatible operators for number columns', () => {
-      const priceColumn: ColumnInfo = productsTableInfo.columns.find(
-        (c) => c.name === 'price',
-      )!;
-
-      const result = validateFilter(
-        { column: 'price', operator: FilterOperator.Like, value: '%100%' },
-        priceColumn,
-      );
-      expect(result.valid).toBe(false);
-      expect(result.error).toContain(
-        "Operator 'like' not supported for column type 'number'",
-      );
-    });
-
-    it('should validate compatible operators for boolean columns', () => {
-      const inStockColumn: ColumnInfo = productsTableInfo.columns.find(
-        (c) => c.name === 'in_stock',
-      )!;
-
-      expect(
-        validateFilter(
-          { column: 'in_stock', operator: FilterOperator.Eq, value: true },
-          inStockColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'in_stock', operator: FilterOperator.Neq, value: false },
-          inStockColumn,
-        ).valid,
-      ).toBe(true);
-      expect(
-        validateFilter(
-          { column: 'in_stock', operator: FilterOperator.IsNull },
-          inStockColumn,
-        ).valid,
-      ).toBe(true);
-    });
-
-    it('should reject incompatible operators for boolean columns', () => {
-      const inStockColumn: ColumnInfo = productsTableInfo.columns.find(
-        (c) => c.name === 'in_stock',
-      )!;
-
-      const result = validateFilter(
-        { column: 'in_stock', operator: FilterOperator.Gt, value: true },
-        inStockColumn,
-      );
-      expect(result.valid).toBe(false);
-    });
-  });
-
-  describe('applyFilters', () => {
-    it('should apply equality filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [
-          {
-            column: 'category',
-            operator: FilterOperator.Eq,
-            value: 'electronics',
-          },
-        ],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(3);
-      results.forEach((r) => expect(r.category).toBe('electronics'));
-    });
-
-    it('should apply not-equal filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [
-          {
-            column: 'category',
-            operator: FilterOperator.Neq,
-            value: 'electronics',
-          },
-        ],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(4);
-      results.forEach((r) => expect(r.category).not.toBe('electronics'));
-    });
-
-    it('should apply greater-than filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'price', operator: FilterOperator.Gt, value: 500 }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(3);
-      results.forEach((r) => expect(Number(r.price)).toBeGreaterThan(500));
-    });
-
-    it('should apply greater-than-or-equal filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'price', operator: FilterOperator.Gte, value: 299.99 }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(4);
-      results.forEach((r) =>
-        expect(Number(r.price)).toBeGreaterThanOrEqual(299.99),
-      );
-    });
-
-    it('should apply less-than filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'price', operator: FilterOperator.Lt, value: 50 }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(3);
-      results.forEach((r) => expect(Number(r.price)).toBeLessThan(50));
-    });
-
-    it('should apply less-than-or-equal filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'price', operator: FilterOperator.Lte, value: 49.99 }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(3);
-      results.forEach((r) =>
-        expect(Number(r.price)).toBeLessThanOrEqual(49.99),
-      );
-    });
-
-    it('should apply LIKE filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'name', operator: FilterOperator.Like, value: 'Laptop%' }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(2);
-      results.forEach((r) => expect(r.name).toMatch(/^Laptop/));
-    });
-
-    it('should apply ILIKE filter (case-insensitive)', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'name', operator: FilterOperator.Ilike, value: '%LAPTOP%' }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(2);
-      results.forEach((r) => expect(r.name.toLowerCase()).toContain('laptop'));
-    });
-
-    it('should apply IN filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [
-          {
-            column: 'category',
-            operator: FilterOperator.In,
-            value: ['electronics', 'furniture'],
-          },
-        ],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(5);
-      results.forEach((r) =>
-        expect(['electronics', 'furniture']).toContain(r.category),
-      );
-    });
-
-    it('should apply NOT IN filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [
-          {
-            column: 'category',
-            operator: FilterOperator.Nin,
-            value: ['electronics', 'furniture'],
-          },
-        ],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(2);
-      results.forEach((r) => expect(r.category).toBe('office'));
-    });
-
-    it('should apply IS NULL filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'rating', operator: FilterOperator.IsNull }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(1);
-      expect(results[0].name).toBe('Standing Desk');
-    });
-
-    it('should apply IS NOT NULL filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'rating', operator: FilterOperator.IsNotNull }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(6);
-      results.forEach((r) => expect(r.rating).not.toBeNull());
-    });
-
-    it('should apply boolean filter', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [{ column: 'in_stock', operator: FilterOperator.Eq, value: false }],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(2);
-      results.forEach((r) => expect(r.inStock).toBe(false));
-    });
-
-    it('should apply multiple filters (AND)', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const filtered = applyFilters(
-        baseQuery,
-        [
-          {
-            column: 'category',
-            operator: FilterOperator.Eq,
-            value: 'electronics',
-          },
-          { column: 'in_stock', operator: FilterOperator.Eq, value: true },
-          { column: 'price', operator: FilterOperator.Lt, value: 1000 },
-        ],
-        productsTableInfo,
-      );
-
-      const results = await filtered.execute();
-      expect(results).toHaveLength(1);
-      expect(results[0].name).toBe('Laptop Basic');
-    });
-
-    it('should throw error for unknown column', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-
-      expect(() =>
-        applyFilters(
-          baseQuery,
-          [
-            {
-              column: 'unknown_column',
-              operator: FilterOperator.Eq,
-              value: 'test',
-            },
-          ],
-          productsTableInfo,
-        ),
-      ).toThrow(
-        "Column 'unknown_column' not found in table 'studio_filter_products'",
-      );
-    });
-
-    it('should throw error for invalid operator', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-
-      expect(() =>
-        applyFilters(
-          baseQuery,
-          [{ column: 'name', operator: FilterOperator.Gt, value: 'test' }],
-          productsTableInfo,
-        ),
-      ).toThrow("Operator 'gt' not supported for column type 'string'");
-    });
-  });
-
-  describe('applySorting', () => {
-    it('should apply ascending sort', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const sorted = applySorting(
-        baseQuery,
-        [{ column: 'price', direction: Direction.Asc }],
-        productsTableInfo,
-      );
-
-      const results = await sorted.execute();
-      expect(results).toHaveLength(7);
-
-      const prices = results.map((r) => Number(r.price));
-      for (let i = 1; i < prices.length; i++) {
-        expect(prices[i]).toBeGreaterThanOrEqual(prices[i - 1]);
-      }
-    });
-
-    it('should apply descending sort', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const sorted = applySorting(
-        baseQuery,
-        [{ column: 'price', direction: Direction.Desc }],
-        productsTableInfo,
-      );
-
-      const results = await sorted.execute();
-      expect(results).toHaveLength(7);
-
-      const prices = results.map((r) => Number(r.price));
-      for (let i = 1; i < prices.length; i++) {
-        expect(prices[i]).toBeLessThanOrEqual(prices[i - 1]);
-      }
-    });
-
-    it('should apply multiple sorts', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const sorted = applySorting(
-        baseQuery,
-        [
-          { column: 'category', direction: Direction.Asc },
-          { column: 'price', direction: Direction.Desc },
-        ],
-        productsTableInfo,
-      );
-
-      const results = await sorted.execute();
-
-      // Group by category and verify price order within each category
-      const electronics = results.filter((r) => r.category === 'electronics');
-      const furniture = results.filter((r) => r.category === 'furniture');
-
-      // Electronics should be first (alphabetically before furniture)
-      expect(results.slice(0, 3).map((r) => r.category)).toEqual([
-        'electronics',
-        'electronics',
-        'electronics',
-      ]);
-
-      // Within electronics, prices should be descending
-      const electronicsPrices = electronics.map((r) => Number(r.price));
-      for (let i = 1; i < electronicsPrices.length; i++) {
-        expect(electronicsPrices[i]).toBeLessThanOrEqual(
-          electronicsPrices[i - 1],
-        );
-      }
-
-      // Within furniture, prices should be descending
-      const furniturePrices = furniture.map((r) => Number(r.price));
-      for (let i = 1; i < furniturePrices.length; i++) {
-        expect(furniturePrices[i]).toBeLessThanOrEqual(furniturePrices[i - 1]);
-      }
-    });
-
-    it('should sort by string column', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-      const sorted = applySorting(
-        baseQuery,
-        [{ column: 'name', direction: Direction.Asc }],
-        productsTableInfo,
-      );
-
-      const results = await sorted.execute();
-      const names = results.map((r) => r.name);
-
-      // Verify alphabetical order
-      const sortedNames = [...names].sort();
-      expect(names).toEqual(sortedNames);
-    });
-
-    it('should throw error for unknown column in sort', async () => {
-      const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
-
-      expect(() =>
-        applySorting(
-          baseQuery,
-          [{ column: 'unknown_column', direction: Direction.Asc }],
-          productsTableInfo,
-        ),
-      ).toThrow(
-        "Column 'unknown_column' not found in table 'studio_filter_products'",
-      );
-    });
-  });
-
-  describe('combined filters and sorting', () => {
-    it('should apply filters then sorting', async () => {
-      let query = db.selectFrom('studioFilterProducts').selectAll();
-
-      // Filter: in stock electronics
-      query = applyFilters(
-        query,
-        [
-          {
-            column: 'category',
-            operator: FilterOperator.Eq,
-            value: 'electronics',
-          },
-          { column: 'in_stock', operator: FilterOperator.Eq, value: true },
-        ],
-        productsTableInfo,
-      );
-
-      // Sort by price descending
-      query = applySorting(
-        query,
-        [{ column: 'price', direction: Direction.Desc }],
-        productsTableInfo,
-      );
-
-      const results = await query.execute();
-
-      expect(results).toHaveLength(2);
-      expect(results[0].name).toBe('Laptop Pro');
-      expect(results[1].name).toBe('Laptop Basic');
-    });
-  });
+	let db: Kysely<TestDatabase>;
+
+	// Table info mock that matches our real table
+	const productsTableInfo: TableInfo = {
+		name: 'studio_filter_products',
+		schema: 'public',
+		columns: [
+			{
+				name: 'id',
+				type: 'number',
+				rawType: 'int4',
+				nullable: false,
+				isPrimaryKey: true,
+				isForeignKey: false,
+			},
+			{
+				name: 'name',
+				type: 'string',
+				rawType: 'varchar',
+				nullable: false,
+				isPrimaryKey: false,
+				isForeignKey: false,
+			},
+			{
+				name: 'price',
+				type: 'number',
+				rawType: 'numeric',
+				nullable: false,
+				isPrimaryKey: false,
+				isForeignKey: false,
+			},
+			{
+				name: 'category',
+				type: 'string',
+				rawType: 'varchar',
+				nullable: false,
+				isPrimaryKey: false,
+				isForeignKey: false,
+			},
+			{
+				name: 'in_stock',
+				type: 'boolean',
+				rawType: 'bool',
+				nullable: false,
+				isPrimaryKey: false,
+				isForeignKey: false,
+			},
+			{
+				name: 'rating',
+				type: 'number',
+				rawType: 'numeric',
+				nullable: true,
+				isPrimaryKey: false,
+				isForeignKey: false,
+			},
+			{
+				name: 'created_at',
+				type: 'datetime',
+				rawType: 'timestamptz',
+				nullable: false,
+				isPrimaryKey: false,
+				isForeignKey: false,
+			},
+		],
+		primaryKey: ['id'],
+	};
+
+	beforeAll(async () => {
+		db = new Kysely<TestDatabase>({
+			dialect: new PostgresDialect({
+				pool: new pg.Pool({
+					...TEST_DATABASE_CONFIG,
+					database: 'postgres',
+				}),
+			}),
+			plugins: [new CamelCasePlugin()],
+		});
+
+		// Create products table
+		await db.schema
+			.createTable('studio_filter_products')
+			.ifNotExists()
+			.addColumn('id', 'serial', (col) => col.primaryKey())
+			.addColumn('name', 'varchar(255)', (col) => col.notNull())
+			.addColumn('price', 'numeric(10, 2)', (col) => col.notNull())
+			.addColumn('category', 'varchar(100)', (col) => col.notNull())
+			.addColumn('in_stock', 'boolean', (col) => col.notNull().defaultTo(true))
+			.addColumn('rating', 'numeric(3, 2)')
+			.addColumn('created_at', 'timestamptz', (col) =>
+				col.defaultTo(sql`now()`).notNull(),
+			)
+			.execute();
+	});
+
+	beforeEach(async () => {
+		// Insert test data
+		await db
+			.insertInto('studioFilterProducts')
+			.values([
+				{
+					name: 'Laptop Pro',
+					price: 1299.99,
+					category: 'electronics',
+					inStock: true,
+					rating: 4.5,
+				},
+				{
+					name: 'Laptop Basic',
+					price: 599.99,
+					category: 'electronics',
+					inStock: true,
+					rating: 3.8,
+				},
+				{
+					name: 'Wireless Mouse',
+					price: 49.99,
+					category: 'electronics',
+					inStock: false,
+					rating: 4.2,
+				},
+				{
+					name: 'Office Chair',
+					price: 299.99,
+					category: 'furniture',
+					inStock: true,
+					rating: 4.0,
+				},
+				{
+					name: 'Standing Desk',
+					price: 549.99,
+					category: 'furniture',
+					inStock: true,
+					rating: null,
+				},
+				{
+					name: 'Notebook',
+					price: 9.99,
+					category: 'office',
+					inStock: true,
+					rating: 3.5,
+				},
+				{
+					name: 'Pen Set',
+					price: 19.99,
+					category: 'office',
+					inStock: false,
+					rating: 4.8,
+				},
+			])
+			.execute();
+	});
+
+	afterEach(async () => {
+		await db.deleteFrom('studioFilterProducts').execute();
+	});
+
+	afterAll(async () => {
+		await db.schema.dropTable('studio_filter_products').ifExists().execute();
+		await db.destroy();
+	});
+
+	describe('validateFilter', () => {
+		it('should validate compatible operators for string columns', () => {
+			const nameColumn: ColumnInfo = productsTableInfo.columns.find(
+				(c) => c.name === 'name',
+			)!;
+
+			expect(
+				validateFilter(
+					{ column: 'name', operator: FilterOperator.Eq, value: 'test' },
+					nameColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'name', operator: FilterOperator.Like, value: '%test%' },
+					nameColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'name', operator: FilterOperator.Ilike, value: '%TEST%' },
+					nameColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'name', operator: FilterOperator.In, value: ['a', 'b'] },
+					nameColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'name', operator: FilterOperator.IsNull },
+					nameColumn,
+				).valid,
+			).toBe(true);
+		});
+
+		it('should reject incompatible operators for string columns', () => {
+			const nameColumn: ColumnInfo = productsTableInfo.columns.find(
+				(c) => c.name === 'name',
+			)!;
+
+			const result = validateFilter(
+				{ column: 'name', operator: FilterOperator.Gt, value: 'test' },
+				nameColumn,
+			);
+			expect(result.valid).toBe(false);
+			expect(result.error).toContain(
+				"Operator 'gt' not supported for column type 'string'",
+			);
+		});
+
+		it('should validate compatible operators for number columns', () => {
+			const priceColumn: ColumnInfo = productsTableInfo.columns.find(
+				(c) => c.name === 'price',
+			)!;
+
+			expect(
+				validateFilter(
+					{ column: 'price', operator: FilterOperator.Eq, value: 100 },
+					priceColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'price', operator: FilterOperator.Gt, value: 100 },
+					priceColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'price', operator: FilterOperator.Gte, value: 100 },
+					priceColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'price', operator: FilterOperator.Lt, value: 100 },
+					priceColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'price', operator: FilterOperator.Lte, value: 100 },
+					priceColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'price', operator: FilterOperator.In, value: [100, 200] },
+					priceColumn,
+				).valid,
+			).toBe(true);
+		});
+
+		it('should reject incompatible operators for number columns', () => {
+			const priceColumn: ColumnInfo = productsTableInfo.columns.find(
+				(c) => c.name === 'price',
+			)!;
+
+			const result = validateFilter(
+				{ column: 'price', operator: FilterOperator.Like, value: '%100%' },
+				priceColumn,
+			);
+			expect(result.valid).toBe(false);
+			expect(result.error).toContain(
+				"Operator 'like' not supported for column type 'number'",
+			);
+		});
+
+		it('should validate compatible operators for boolean columns', () => {
+			const inStockColumn: ColumnInfo = productsTableInfo.columns.find(
+				(c) => c.name === 'in_stock',
+			)!;
+
+			expect(
+				validateFilter(
+					{ column: 'in_stock', operator: FilterOperator.Eq, value: true },
+					inStockColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'in_stock', operator: FilterOperator.Neq, value: false },
+					inStockColumn,
+				).valid,
+			).toBe(true);
+			expect(
+				validateFilter(
+					{ column: 'in_stock', operator: FilterOperator.IsNull },
+					inStockColumn,
+				).valid,
+			).toBe(true);
+		});
+
+		it('should reject incompatible operators for boolean columns', () => {
+			const inStockColumn: ColumnInfo = productsTableInfo.columns.find(
+				(c) => c.name === 'in_stock',
+			)!;
+
+			const result = validateFilter(
+				{ column: 'in_stock', operator: FilterOperator.Gt, value: true },
+				inStockColumn,
+			);
+			expect(result.valid).toBe(false);
+		});
+	});
+
+	describe('applyFilters', () => {
+		it('should apply equality filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[
+					{
+						column: 'category',
+						operator: FilterOperator.Eq,
+						value: 'electronics',
+					},
+				],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(3);
+			results.forEach((r) => expect(r.category).toBe('electronics'));
+		});
+
+		it('should apply not-equal filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[
+					{
+						column: 'category',
+						operator: FilterOperator.Neq,
+						value: 'electronics',
+					},
+				],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(4);
+			results.forEach((r) => expect(r.category).not.toBe('electronics'));
+		});
+
+		it('should apply greater-than filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'price', operator: FilterOperator.Gt, value: 500 }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(3);
+			results.forEach((r) => expect(Number(r.price)).toBeGreaterThan(500));
+		});
+
+		it('should apply greater-than-or-equal filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'price', operator: FilterOperator.Gte, value: 299.99 }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(4);
+			results.forEach((r) =>
+				expect(Number(r.price)).toBeGreaterThanOrEqual(299.99),
+			);
+		});
+
+		it('should apply less-than filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'price', operator: FilterOperator.Lt, value: 50 }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(3);
+			results.forEach((r) => expect(Number(r.price)).toBeLessThan(50));
+		});
+
+		it('should apply less-than-or-equal filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'price', operator: FilterOperator.Lte, value: 49.99 }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(3);
+			results.forEach((r) =>
+				expect(Number(r.price)).toBeLessThanOrEqual(49.99),
+			);
+		});
+
+		it('should apply LIKE filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'name', operator: FilterOperator.Like, value: 'Laptop%' }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(2);
+			results.forEach((r) => expect(r.name).toMatch(/^Laptop/));
+		});
+
+		it('should apply ILIKE filter (case-insensitive)', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'name', operator: FilterOperator.Ilike, value: '%LAPTOP%' }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(2);
+			results.forEach((r) => expect(r.name.toLowerCase()).toContain('laptop'));
+		});
+
+		it('should apply IN filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[
+					{
+						column: 'category',
+						operator: FilterOperator.In,
+						value: ['electronics', 'furniture'],
+					},
+				],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(5);
+			results.forEach((r) =>
+				expect(['electronics', 'furniture']).toContain(r.category),
+			);
+		});
+
+		it('should apply NOT IN filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[
+					{
+						column: 'category',
+						operator: FilterOperator.Nin,
+						value: ['electronics', 'furniture'],
+					},
+				],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(2);
+			results.forEach((r) => expect(r.category).toBe('office'));
+		});
+
+		it('should apply IS NULL filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'rating', operator: FilterOperator.IsNull }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(1);
+			expect(results[0].name).toBe('Standing Desk');
+		});
+
+		it('should apply IS NOT NULL filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'rating', operator: FilterOperator.IsNotNull }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(6);
+			results.forEach((r) => expect(r.rating).not.toBeNull());
+		});
+
+		it('should apply boolean filter', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[{ column: 'in_stock', operator: FilterOperator.Eq, value: false }],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(2);
+			results.forEach((r) => expect(r.inStock).toBe(false));
+		});
+
+		it('should apply multiple filters (AND)', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const filtered = applyFilters(
+				baseQuery,
+				[
+					{
+						column: 'category',
+						operator: FilterOperator.Eq,
+						value: 'electronics',
+					},
+					{ column: 'in_stock', operator: FilterOperator.Eq, value: true },
+					{ column: 'price', operator: FilterOperator.Lt, value: 1000 },
+				],
+				productsTableInfo,
+			);
+
+			const results = await filtered.execute();
+			expect(results).toHaveLength(1);
+			expect(results[0].name).toBe('Laptop Basic');
+		});
+
+		it('should throw error for unknown column', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+
+			expect(() =>
+				applyFilters(
+					baseQuery,
+					[
+						{
+							column: 'unknown_column',
+							operator: FilterOperator.Eq,
+							value: 'test',
+						},
+					],
+					productsTableInfo,
+				),
+			).toThrow(
+				"Column 'unknown_column' not found in table 'studio_filter_products'",
+			);
+		});
+
+		it('should throw error for invalid operator', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+
+			expect(() =>
+				applyFilters(
+					baseQuery,
+					[{ column: 'name', operator: FilterOperator.Gt, value: 'test' }],
+					productsTableInfo,
+				),
+			).toThrow("Operator 'gt' not supported for column type 'string'");
+		});
+	});
+
+	describe('applySorting', () => {
+		it('should apply ascending sort', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const sorted = applySorting(
+				baseQuery,
+				[{ column: 'price', direction: Direction.Asc }],
+				productsTableInfo,
+			);
+
+			const results = await sorted.execute();
+			expect(results).toHaveLength(7);
+
+			const prices = results.map((r) => Number(r.price));
+			for (let i = 1; i < prices.length; i++) {
+				expect(prices[i]).toBeGreaterThanOrEqual(prices[i - 1]);
+			}
+		});
+
+		it('should apply descending sort', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const sorted = applySorting(
+				baseQuery,
+				[{ column: 'price', direction: Direction.Desc }],
+				productsTableInfo,
+			);
+
+			const results = await sorted.execute();
+			expect(results).toHaveLength(7);
+
+			const prices = results.map((r) => Number(r.price));
+			for (let i = 1; i < prices.length; i++) {
+				expect(prices[i]).toBeLessThanOrEqual(prices[i - 1]);
+			}
+		});
+
+		it('should apply multiple sorts', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const sorted = applySorting(
+				baseQuery,
+				[
+					{ column: 'category', direction: Direction.Asc },
+					{ column: 'price', direction: Direction.Desc },
+				],
+				productsTableInfo,
+			);
+
+			const results = await sorted.execute();
+
+			// Group by category and verify price order within each category
+			const electronics = results.filter((r) => r.category === 'electronics');
+			const furniture = results.filter((r) => r.category === 'furniture');
+
+			// Electronics should be first (alphabetically before furniture)
+			expect(results.slice(0, 3).map((r) => r.category)).toEqual([
+				'electronics',
+				'electronics',
+				'electronics',
+			]);
+
+			// Within electronics, prices should be descending
+			const electronicsPrices = electronics.map((r) => Number(r.price));
+			for (let i = 1; i < electronicsPrices.length; i++) {
+				expect(electronicsPrices[i]).toBeLessThanOrEqual(
+					electronicsPrices[i - 1],
+				);
+			}
+
+			// Within furniture, prices should be descending
+			const furniturePrices = furniture.map((r) => Number(r.price));
+			for (let i = 1; i < furniturePrices.length; i++) {
+				expect(furniturePrices[i]).toBeLessThanOrEqual(furniturePrices[i - 1]);
+			}
+		});
+
+		it('should sort by string column', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+			const sorted = applySorting(
+				baseQuery,
+				[{ column: 'name', direction: Direction.Asc }],
+				productsTableInfo,
+			);
+
+			const results = await sorted.execute();
+			const names = results.map((r) => r.name);
+
+			// Verify alphabetical order
+			const sortedNames = [...names].sort();
+			expect(names).toEqual(sortedNames);
+		});
+
+		it('should throw error for unknown column in sort', async () => {
+			const baseQuery = db.selectFrom('studioFilterProducts').selectAll();
+
+			expect(() =>
+				applySorting(
+					baseQuery,
+					[{ column: 'unknown_column', direction: Direction.Asc }],
+					productsTableInfo,
+				),
+			).toThrow(
+				"Column 'unknown_column' not found in table 'studio_filter_products'",
+			);
+		});
+	});
+
+	describe('combined filters and sorting', () => {
+		it('should apply filters then sorting', async () => {
+			let query = db.selectFrom('studioFilterProducts').selectAll();
+
+			// Filter: in stock electronics
+			query = applyFilters(
+				query,
+				[
+					{
+						column: 'category',
+						operator: FilterOperator.Eq,
+						value: 'electronics',
+					},
+					{ column: 'in_stock', operator: FilterOperator.Eq, value: true },
+				],
+				productsTableInfo,
+			);
+
+			// Sort by price descending
+			query = applySorting(
+				query,
+				[{ column: 'price', direction: Direction.Desc }],
+				productsTableInfo,
+			);
+
+			const results = await query.execute();
+
+			expect(results).toHaveLength(2);
+			expect(results[0].name).toBe('Laptop Pro');
+			expect(results[1].name).toBe('Laptop Basic');
+		});
+	});
 });