piper-utils 1.1.68 → 1.1.70

package/src/database/dbUtils/queryStringUtils/createFilters.test.js

@@ -1,682 +1,682 @@
-import { createFilters } from './createFilters.js';
-import { defaultFilters } from './defaultFilters.js';
-import { defaultFiltersWithSubSchema, event, eventWithSearchString, eventWithSearchStringNumber, eventWithSingleElementAsArray, eventWithSingleElementInArray, manyStringFields } from './mocks/mocks.js';
-import DB from 'sequelize';
-
-describe('createFilters', function () {
-    it('should produce case insensitive string filters using LOWER and Op.like', function () {
-        // Arrange
-        const mockEvent = {
-            ...event,
-            queryStringParameters: {
-                ...event.queryStringParameters,
-                char: 'MiXeDcAsE'
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, defaultFiltersWithSubSchema);
-
-        // Assert
-        expect(where[DB.Op.and]).toBeDefined();
-        const charCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.col === 'char');
-        expect(charCondition).toBeDefined();
-        expect(charCondition.attribute.fn).toBe('LOWER');
-        expect(charCondition.logic[DB.Op.like]).toBe('%mixedcase%');
-    });
-
-    it('should return a Sequelize WHERE object and include createdAt', function () {
-        // Act
-        const where = createFilters(event, defaultFiltersWithSubSchema);
-
-        // Assert
-        expect(where.createdAt).toBeDefined();
-        expect(where.decimal).toEqual({ [DB.Op.or]: [-4565, 4565] });
-        expect(where[DB.Op.and]).toBeDefined();
-        expect(where.boolean).toEqual({ [DB.Op.eq]: true });
-        expect(where.array).toEqual({ [DB.Op.in]: ['10', '20', '30'] });
-        expect(where['$snowman.snowmanType$']).toEqual({ [DB.Op.eq]: 10 });
-        expect(where.notOnObject).not.toBeDefined();
-        expect(where.date).not.toBeDefined();
-    });
-
-    it('should handle single elements in the in array', function () {
-        // Act
-        const where = createFilters(eventWithSingleElementInArray, defaultFiltersWithSubSchema);
-
-        // Assert
-        expect(where.array).toEqual({ [DB.Op.in]: ['10'] });
-        expect(where.notOnObject).not.toBeDefined();
-        expect(where.date).not.toBeDefined();
-    });
-
-    it('should handle the array value being one value', function () {
-        // Act
-        const where = createFilters(eventWithSingleElementAsArray, defaultFiltersWithSubSchema);
-
-        // Assert
-        expect(where.array).toEqual({ [DB.Op.in]: ['10'] });
-        expect(where.notOnObject).not.toBeDefined();
-        expect(where.date).not.toBeDefined();
-    });
-
-    it('should handle searchString with case insensitive LOWER + Op.like conditions', function () {
-        // Act
-        const where = createFilters(eventWithSearchString, manyStringFields);
-
-        // Assert
-        const orSymbols = Object.getOwnPropertySymbols(where);
-        expect(orSymbols.length).toBeGreaterThan(0);
-        const orConditions = where[DB.Op.or];
-        const lowerConditions = orConditions.filter(c => c.attribute?.fn === 'LOWER');
-        expect(lowerConditions.length).toBeGreaterThan(0);
-        lowerConditions.forEach(c => {
-            expect(c.logic[DB.Op.like]).toBe('%alpha-search%');
-        });
-    });
-
-    it('should handle searchString if value is a number', function () {
-        // Act
-        const where = createFilters(eventWithSearchStringNumber, manyStringFields);
-
-        // Assert
-        const orSymbols = Object.getOwnPropertySymbols(where);
-        expect(orSymbols.length).toBeGreaterThan(0);
-    });
-
-    it('should handle searchString sub fields', function () {
-        // Act
-        const where = createFilters(eventWithSearchStringNumber, defaultFiltersWithSubSchema);
-
-        // Assert
-        const orSymbols = Object.getOwnPropertySymbols(where);
-        expect(orSymbols.length).toBeGreaterThan(0);
-    });
-
-    it('should not place string filter fields as direct keys on the where object', function () {
-        // Act
-        const where = createFilters(event, defaultFiltersWithSubSchema);
-
-        // Assert - char is a string field, it should be in Op.and not as a direct key
-        expect(where.char).not.toBeDefined();
-        expect(where[DB.Op.and]).toBeDefined();
-    });
-});
-
-describe('JSONB case insensitive filters', () => {
-    it('should lowercase a single-level JSONB path search', function () {
-        // Arrange
-        const mockEvent = {
-            queryStringParameters: {
-                'token.cardHolderName': 'GREGORY HERBERT'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        expect(where[DB.Op.and]).toBeDefined();
-        expect(where[DB.Op.and].length).toBe(1);
-        const condition = where[DB.Op.and][0];
-        expect(condition.attribute.fn).toBe('LOWER');
-        expect(condition.logic[DB.Op.like]).toBe('%gregory herbert%');
-    });
-
-    it('should use jsonb_extract_path_text with the correct column and path parts', function () {
-        // Arrange
-        const mockEvent = {
-            queryStringParameters: {
-                'token.cardHolderName': 'Test Name'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        const condition = where[DB.Op.and][0];
-        const innerFn = condition.attribute.args[0];
-        expect(innerFn.fn).toBe('jsonb_extract_path_text');
-        expect(innerFn.args[0].col).toBe('token');
-        expect(innerFn.args[1]).toBe('cardHolderName');
-    });
-
-    it('should pass each segment as a separate arg for deeply nested JSONB paths', function () {
-        // Arrange
-        const mockEvent = {
-            queryStringParameters: {
-                'paymentProviderData.payment.result.message': 'THE NAME'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            paymentProviderData: { type: 'jsonb', field: 'paymentProviderData' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        const condition = where[DB.Op.and][0];
-        const innerFn = condition.attribute.args[0];
-        expect(innerFn.fn).toBe('jsonb_extract_path_text');
-        expect(innerFn.args[0].col).toBe('paymentProviderData');
-        expect(innerFn.args[1]).toBe('payment');
-        expect(innerFn.args[2]).toBe('result');
-        expect(innerFn.args[3]).toBe('message');
-        expect(condition.logic[DB.Op.like]).toBe('%the name%');
-    });
-
-    it('should create a condition for each JSONB query param', function () {
-        // Arrange
-        const mockEvent = {
-            queryStringParameters: {
-                'token.cardHolderName': 'Gregory',
-                'token.cardType': 'MASTERCARD'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        expect(where[DB.Op.and].length).toBe(2);
-        const values = where[DB.Op.and].map(c => c.logic[DB.Op.like]);
-        expect(values).toContain('%gregory%');
-        expect(values).toContain('%mastercard%');
-    });
-
-    it('should not add Op.and when no JSONB query params match the filter prefix', function () {
-        // Arrange
-        const mockEvent = {
-            queryStringParameters: {
-                'unrelated': 'value'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        expect(where[DB.Op.and]).not.toBeDefined();
-    });
-
-    it('should combine JSONB conditions with string field conditions in Op.and', function () {
-        // Arrange
-        const mockEvent = {
-            queryStringParameters: {
-                name: 'John',
-                'token.cardHolderName': 'GREGORY'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            name: { filterType: DB.Op.iLike },
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        expect(where[DB.Op.and].length).toBe(2);
-        const stringCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.col === 'name');
-        expect(stringCondition).toBeDefined();
-        expect(stringCondition.logic[DB.Op.like]).toBe('%john%');
-        const jsonbCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.fn === 'jsonb_extract_path_text');
-        expect(jsonbCondition).toBeDefined();
-        expect(jsonbCondition.logic[DB.Op.like]).toBe('%gregory%');
-    });
-
-    it('should handle a JSON object passed as the JSONB field value (e.g. ?token={"cardHolderName":"Test"})', function () {
-        // Arrange — simulates ?token={"cardHolderName":"Test"} (URL-decoded)
-        const mockEvent = {
-            queryStringParameters: {
-                token: '{"cardHolderName":"Test"}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert — should NOT place token as a direct key
-        expect(where.token).not.toBeDefined();
-        // Should create a JSONB condition in Op.and
-        expect(where[DB.Op.and]).toBeDefined();
-        expect(where[DB.Op.and].length).toBe(1);
-        const condition = where[DB.Op.and][0];
-        expect(condition.attribute.fn).toBe('LOWER');
-        const innerFn = condition.attribute.args[0];
-        expect(innerFn.fn).toBe('jsonb_extract_path_text');
-        expect(innerFn.args[0].col).toBe('token');
-        expect(innerFn.args[1]).toBe('cardHolderName');
-        expect(condition.logic[DB.Op.like]).toBe('%test%');
-    });
-
-    it('should handle a JSON object with multiple keys passed as the JSONB field value', function () {
-        // Arrange — simulates ?token={"cardHolderName":"Test","cardType":"Mastercard"}
-        const mockEvent = {
-            queryStringParameters: {
-                token: '{"cardHolderName":"Test","cardType":"Mastercard"}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        expect(where[DB.Op.and].length).toBe(2);
-        const values = where[DB.Op.and].map(c => c.logic[DB.Op.like]);
-        expect(values).toContain('%test%');
-        expect(values).toContain('%mastercard%');
-    });
-
-    it('should not place the JSONB field as a direct key on the where object', function () {
-        // Arrange
-        const mockEvent = {
-            queryStringParameters: {
-                'token.cardHolderName': 'Test'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:businessIds': '[\'1\']',
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert
-        expect(where.token).not.toBeDefined();
-        expect(where[DB.Op.and]).toBeDefined();
-    });
-});
-
-describe('JSONB filters via defaultFilters integration', () => {
-    it('should case-insensitive search a JSONB field using a JSON object query param', function () {
-        // Arrange — schema mirrors payment.js: token is DB.JSONB
-        const schema = {
-            token: { type: DB.JSONB(), defaultValue: {} },
-            amount: { type: DB.DECIMAL() }
-        };
-        const filters = defaultFilters(schema);
-        const mockEvent = {
-            queryStringParameters: {
-                token: '{"cardHolderName":"Test"}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, filters);
-
-        // Assert — token should not be a direct key (no Op.contains)
-        expect(where.token).not.toBeDefined();
-        // Should produce a case-insensitive jsonb_extract_path_text condition
-        expect(where[DB.Op.and]).toBeDefined();
-        const condition = where[DB.Op.and][0];
-        expect(condition.attribute.fn).toBe('LOWER');
-        const innerFn = condition.attribute.args[0];
-        expect(innerFn.fn).toBe('jsonb_extract_path_text');
-        expect(innerFn.args[0].col).toBe('token');
-        expect(innerFn.args[1]).toBe('cardHolderName');
-        expect(condition.logic[DB.Op.like]).toBe('%test%');
-    });
-
-    it('should case-insensitive search a JSONB field using dot-notation query param', function () {
-        // Arrange
-        const schema = {
-            token: { type: DB.JSONB(), defaultValue: {} }
-        };
-        const filters = defaultFilters(schema);
-        const mockEvent = {
-            queryStringParameters: {
-                'token.lastFour': '8473'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, filters);
-
-        // Assert
-        expect(where.token).not.toBeDefined();
-        expect(where[DB.Op.and]).toBeDefined();
-        const condition = where[DB.Op.and][0];
-        const innerFn = condition.attribute.args[0];
-        expect(innerFn.fn).toBe('jsonb_extract_path_text');
-        expect(innerFn.args[0].col).toBe('token');
-        expect(innerFn.args[1]).toBe('lastFour');
-        expect(condition.logic[DB.Op.like]).toBe('%8473%');
-    });
-
-    it('should handle multiple JSONB columns in the same schema', function () {
-        // Arrange — mirrors payment schema with token and paymentProviderData
-        const schema = {
-            token: { type: DB.JSONB(), defaultValue: {} },
-            paymentProviderData: { type: DB.JSONB() }
-        };
-        const filters = defaultFilters(schema);
-        const mockEvent = {
-            queryStringParameters: {
-                'token.cardHolderName': 'Gregory',
-                'paymentProviderData.payment.result.message': 'APPROVED'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, filters);
-
-        // Assert
-        expect(where.token).not.toBeDefined();
-        expect(where.paymentProviderData).not.toBeDefined();
-        expect(where[DB.Op.and].length).toBe(2);
-        const tokenCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.args?.[0]?.col === 'token');
-        expect(tokenCondition).toBeDefined();
-        expect(tokenCondition.logic[DB.Op.like]).toBe('%gregory%');
-        const providerCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.args?.[0]?.col === 'paymentProviderData');
-        expect(providerCondition).toBeDefined();
-        expect(providerCondition.logic[DB.Op.like]).toBe('%approved%');
-    });
-
-    it('should combine JSONB filters with non-JSONB filters from the same schema', function () {
-        // Arrange
-        const schema = {
-            token: { type: DB.JSONB(), defaultValue: {} },
-            amount: { type: DB.DECIMAL() },
-            status: { type: DB.STRING(20) }
-        };
-        const filters = defaultFilters(schema);
-        const mockEvent = {
-            queryStringParameters: {
-                token: '{"cardType":"Mastercard"}',
-                amount: '100',
-                status: 'Complete'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, filters);
-
-        // Assert — amount uses Op.or (DECIMAL), status uses LOWER+LIKE (STRING)
-        expect(where.amount).toEqual({ [DB.Op.or]: [-100, 100] });
-        expect(where.token).not.toBeDefined();
-        // Op.and should contain both the string condition (status) and the JSONB condition (token)
-        expect(where[DB.Op.and]).toBeDefined();
-        const statusCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.col === 'status');
-        expect(statusCondition).toBeDefined();
-        expect(statusCondition.logic[DB.Op.like]).toBe('%complete%');
-        const jsonbCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.fn === 'jsonb_extract_path_text');
-        expect(jsonbCondition).toBeDefined();
-        expect(jsonbCondition.logic[DB.Op.like]).toBe('%mastercard%');
-    });
-
-    it('should handle JSONB type passed as class reference instead of instance', function () {
-        // Arrange — real schemas like payment.js use db.JSONB (class) not db.JSONB() (instance)
-        const schema = {
-            token: { type: DB.JSONB, defaultValue: {} }
-        };
-        const filters = defaultFilters(schema);
-        const mockEvent = {
-            queryStringParameters: {
-                token: '{"cardHolderName":"Test"}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, filters);
-
-        // Assert — should work the same as the instance form
-        expect(where.token).not.toBeDefined();
-        expect(where[DB.Op.and]).toBeDefined();
-        const condition = where[DB.Op.and][0];
-        expect(condition.attribute.fn).toBe('LOWER');
-        expect(condition.logic[DB.Op.like]).toBe('%test%');
-    });
-
-    it('should handle numeric values in a JSON object query param', function () {
-        // Arrange — e.g. ?token={"firstSix":123456}
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-        const mockEvent = {
-            queryStringParameters: {
-                token: '{"firstSix":123456}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert — number should be stringified correctly
-        expect(where[DB.Op.and]).toBeDefined();
-        expect(where[DB.Op.and].length).toBe(1);
-        const condition = where[DB.Op.and][0];
-        const innerFn = condition.attribute.args[0];
-        expect(innerFn.fn).toBe('jsonb_extract_path_text');
-        expect(innerFn.args[1]).toBe('firstSix');
-        expect(condition.logic[DB.Op.like]).toBe('%123456%');
-    });
-
-    it('should recursively flatten nested objects into deeper jsonb_extract_path_text paths', function () {
-        // Arrange — e.g. ?paymentProviderData={"payment":{"result":{"message":"Approved"}}}
-        const mockFilter = {
-            paymentProviderData: { type: 'jsonb', field: 'paymentProviderData' }
-        };
-        const mockEvent = {
-            queryStringParameters: {
-                paymentProviderData: '{"payment":{"result":{"message":"Approved"}}}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert — should flatten to jsonb_extract_path_text("paymentProviderData", 'payment', 'result', 'message')
-        expect(where[DB.Op.and]).toBeDefined();
-        expect(where[DB.Op.and].length).toBe(1);
-        const condition = where[DB.Op.and][0];
-        const innerFn = condition.attribute.args[0];
-        expect(innerFn.fn).toBe('jsonb_extract_path_text');
-        expect(innerFn.args[0].col).toBe('paymentProviderData');
-        expect(innerFn.args[1]).toBe('payment');
-        expect(innerFn.args[2]).toBe('result');
-        expect(innerFn.args[3]).toBe('message');
-        expect(condition.logic[DB.Op.like]).toBe('%approved%');
-    });
-
-    it('should skip null and array values in a JSON object query param', function () {
-        // Arrange — null and array values should be ignored
-        const mockFilter = {
-            token: { type: 'jsonb', field: 'token' }
-        };
-        const mockEvent = {
-            queryStringParameters: {
-                token: '{"cardHolderName":"Test","tags":["a","b"],"removed":null}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert — only cardHolderName should produce a condition
-        expect(where[DB.Op.and]).toBeDefined();
-        expect(where[DB.Op.and].length).toBe(1);
-        expect(where[DB.Op.and][0].logic[DB.Op.like]).toBe('%test%');
-    });
-
-    it('should handle a mix of nested and primitive values in a JSON object', function () {
-        // Arrange — e.g. ?data={"status":"active","meta":{"region":"US"}}
-        const mockFilter = {
-            data: { type: 'jsonb', field: 'data' }
-        };
-        const mockEvent = {
-            queryStringParameters: {
-                data: '{"status":"active","meta":{"region":"US"}}'
-            },
-            requestContext: {
-                authorizer: {
-                    claims: {
-                        'custom:AR': '{"businessIds":{"1":"A"}}'
-                    }
-                }
-            }
-        };
-
-        // Act
-        const where = createFilters(mockEvent, mockFilter);
-
-        // Assert — should produce two conditions: one flat, one nested
-        expect(where[DB.Op.and]).toBeDefined();
-        expect(where[DB.Op.and].length).toBe(2);
-        const statusCondition = where[DB.Op.and].find(c => c.logic[DB.Op.like] === '%active%');
-        expect(statusCondition).toBeDefined();
-        expect(statusCondition.attribute.args[0].args[1]).toBe('status');
-        const regionCondition = where[DB.Op.and].find(c => c.logic[DB.Op.like] === '%us%');
-        expect(regionCondition).toBeDefined();
-        expect(regionCondition.attribute.args[0].args[1]).toBe('meta');
-        expect(regionCondition.attribute.args[0].args[2]).toBe('region');
-    });
-});
+import { createFilters } from './createFilters.js';
+import { defaultFilters } from './defaultFilters.js';
+import { defaultFiltersWithSubSchema, event, eventWithSearchString, eventWithSearchStringNumber, eventWithSingleElementAsArray, eventWithSingleElementInArray, manyStringFields } from './mocks/mocks.js';
+import DB from 'sequelize';
+
+describe('createFilters', function () {
+    it('should produce case insensitive string filters using LOWER and Op.like', function () {
+        // Arrange
+        const mockEvent = {
+            ...event,
+            queryStringParameters: {
+                ...event.queryStringParameters,
+                char: 'MiXeDcAsE'
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, defaultFiltersWithSubSchema);
+
+        // Assert
+        expect(where[DB.Op.and]).toBeDefined();
+        const charCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.col === 'char');
+        expect(charCondition).toBeDefined();
+        expect(charCondition.attribute.fn).toBe('LOWER');
+        expect(charCondition.logic[DB.Op.like]).toBe('%mixedcase%');
+    });
+
+    it('should return a Sequelize WHERE object and include createdAt', function () {
+        // Act
+        const where = createFilters(event, defaultFiltersWithSubSchema);
+
+        // Assert
+        expect(where.createdAt).toBeDefined();
+        expect(where.decimal).toEqual({ [DB.Op.or]: [-4565, 4565] });
+        expect(where[DB.Op.and]).toBeDefined();
+        expect(where.boolean).toEqual({ [DB.Op.eq]: true });
+        expect(where.array).toEqual({ [DB.Op.in]: ['10', '20', '30'] });
+        expect(where['$snowman.snowmanType$']).toEqual({ [DB.Op.eq]: 10 });
+        expect(where.notOnObject).not.toBeDefined();
+        expect(where.date).not.toBeDefined();
+    });
+
+    it('should handle single elements in the in array', function () {
+        // Act
+        const where = createFilters(eventWithSingleElementInArray, defaultFiltersWithSubSchema);
+
+        // Assert
+        expect(where.array).toEqual({ [DB.Op.in]: ['10'] });
+        expect(where.notOnObject).not.toBeDefined();
+        expect(where.date).not.toBeDefined();
+    });
+
+    it('should handle the array value being one value', function () {
+        // Act
+        const where = createFilters(eventWithSingleElementAsArray, defaultFiltersWithSubSchema);
+
+        // Assert
+        expect(where.array).toEqual({ [DB.Op.in]: ['10'] });
+        expect(where.notOnObject).not.toBeDefined();
+        expect(where.date).not.toBeDefined();
+    });
+
+    it('should handle searchString with case insensitive LOWER + Op.like conditions', function () {
+        // Act
+        const where = createFilters(eventWithSearchString, manyStringFields);
+
+        // Assert
+        const orSymbols = Object.getOwnPropertySymbols(where);
+        expect(orSymbols.length).toBeGreaterThan(0);
+        const orConditions = where[DB.Op.or];
+        const lowerConditions = orConditions.filter(c => c.attribute?.fn === 'LOWER');
+        expect(lowerConditions.length).toBeGreaterThan(0);
+        lowerConditions.forEach(c => {
+            expect(c.logic[DB.Op.like]).toBe('%alpha-search%');
+        });
+    });
+
+    it('should handle searchString if value is a number', function () {
+        // Act
+        const where = createFilters(eventWithSearchStringNumber, manyStringFields);
+
+        // Assert
+        const orSymbols = Object.getOwnPropertySymbols(where);
+        expect(orSymbols.length).toBeGreaterThan(0);
+    });
+
+    it('should handle searchString sub fields', function () {
+        // Act
+        const where = createFilters(eventWithSearchStringNumber, defaultFiltersWithSubSchema);
+
+        // Assert
+        const orSymbols = Object.getOwnPropertySymbols(where);
+        expect(orSymbols.length).toBeGreaterThan(0);
+    });
+
+    it('should not place string filter fields as direct keys on the where object', function () {
+        // Act
+        const where = createFilters(event, defaultFiltersWithSubSchema);
+
+        // Assert - char is a string field, it should be in Op.and not as a direct key
+        expect(where.char).not.toBeDefined();
+        expect(where[DB.Op.and]).toBeDefined();
+    });
+});
+
+describe('JSONB case insensitive filters', () => {
+    it('should lowercase a single-level JSONB path search', function () {
+        // Arrange
+        const mockEvent = {
+            queryStringParameters: {
+                'token.cardHolderName': 'GREGORY HERBERT'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        expect(where[DB.Op.and]).toBeDefined();
+        expect(where[DB.Op.and].length).toBe(1);
+        const condition = where[DB.Op.and][0];
+        expect(condition.attribute.fn).toBe('LOWER');
+        expect(condition.logic[DB.Op.like]).toBe('%gregory herbert%');
+    });
+
+    it('should use jsonb_extract_path_text with the correct column and path parts', function () {
+        // Arrange
+        const mockEvent = {
+            queryStringParameters: {
+                'token.cardHolderName': 'Test Name'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        const condition = where[DB.Op.and][0];
+        const innerFn = condition.attribute.args[0];
+        expect(innerFn.fn).toBe('jsonb_extract_path_text');
+        expect(innerFn.args[0].col).toBe('token');
+        expect(innerFn.args[1]).toBe('cardHolderName');
+    });
+
+    it('should pass each segment as a separate arg for deeply nested JSONB paths', function () {
+        // Arrange
+        const mockEvent = {
+            queryStringParameters: {
+                'paymentProviderData.payment.result.message': 'THE NAME'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            paymentProviderData: { type: 'jsonb', field: 'paymentProviderData' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        const condition = where[DB.Op.and][0];
+        const innerFn = condition.attribute.args[0];
+        expect(innerFn.fn).toBe('jsonb_extract_path_text');
+        expect(innerFn.args[0].col).toBe('paymentProviderData');
+        expect(innerFn.args[1]).toBe('payment');
+        expect(innerFn.args[2]).toBe('result');
+        expect(innerFn.args[3]).toBe('message');
+        expect(condition.logic[DB.Op.like]).toBe('%the name%');
+    });
+
+    it('should create a condition for each JSONB query param', function () {
+        // Arrange
+        const mockEvent = {
+            queryStringParameters: {
+                'token.cardHolderName': 'Gregory',
+                'token.cardType': 'MASTERCARD'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        expect(where[DB.Op.and].length).toBe(2);
+        const values = where[DB.Op.and].map(c => c.logic[DB.Op.like]);
+        expect(values).toContain('%gregory%');
+        expect(values).toContain('%mastercard%');
+    });
+
+    it('should not add Op.and when no JSONB query params match the filter prefix', function () {
+        // Arrange
+        const mockEvent = {
+            queryStringParameters: {
+                'unrelated': 'value'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        expect(where[DB.Op.and]).not.toBeDefined();
+    });
+
+    it('should combine JSONB conditions with string field conditions in Op.and', function () {
+        // Arrange
+        const mockEvent = {
+            queryStringParameters: {
+                name: 'John',
+                'token.cardHolderName': 'GREGORY'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            name: { filterType: DB.Op.iLike },
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        expect(where[DB.Op.and].length).toBe(2);
+        const stringCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.col === 'name');
+        expect(stringCondition).toBeDefined();
+        expect(stringCondition.logic[DB.Op.like]).toBe('%john%');
+        const jsonbCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.fn === 'jsonb_extract_path_text');
+        expect(jsonbCondition).toBeDefined();
+        expect(jsonbCondition.logic[DB.Op.like]).toBe('%gregory%');
+    });
+
+    it('should handle a JSON object passed as the JSONB field value (e.g. ?token={"cardHolderName":"Test"})', function () {
+        // Arrange — simulates ?token={"cardHolderName":"Test"} (URL-decoded)
+        const mockEvent = {
+            queryStringParameters: {
+                token: '{"cardHolderName":"Test"}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert — should NOT place token as a direct key
+        expect(where.token).not.toBeDefined();
+        // Should create a JSONB condition in Op.and
+        expect(where[DB.Op.and]).toBeDefined();
+        expect(where[DB.Op.and].length).toBe(1);
+        const condition = where[DB.Op.and][0];
+        expect(condition.attribute.fn).toBe('LOWER');
+        const innerFn = condition.attribute.args[0];
+        expect(innerFn.fn).toBe('jsonb_extract_path_text');
+        expect(innerFn.args[0].col).toBe('token');
+        expect(innerFn.args[1]).toBe('cardHolderName');
+        expect(condition.logic[DB.Op.like]).toBe('%test%');
+    });
+
+    it('should handle a JSON object with multiple keys passed as the JSONB field value', function () {
+        // Arrange — simulates ?token={"cardHolderName":"Test","cardType":"Mastercard"}
+        const mockEvent = {
+            queryStringParameters: {
+                token: '{"cardHolderName":"Test","cardType":"Mastercard"}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        expect(where[DB.Op.and].length).toBe(2);
+        const values = where[DB.Op.and].map(c => c.logic[DB.Op.like]);
+        expect(values).toContain('%test%');
+        expect(values).toContain('%mastercard%');
+    });
+
+    it('should not place the JSONB field as a direct key on the where object', function () {
+        // Arrange
+        const mockEvent = {
+            queryStringParameters: {
+                'token.cardHolderName': 'Test'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:businessIds': '[\'1\']',
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert
+        expect(where.token).not.toBeDefined();
+        expect(where[DB.Op.and]).toBeDefined();
+    });
+});
+
+describe('JSONB filters via defaultFilters integration', () => {
+    it('should case-insensitive search a JSONB field using a JSON object query param', function () {
+        // Arrange — schema mirrors payment.js: token is DB.JSONB
+        const schema = {
+            token: { type: DB.JSONB(), defaultValue: {} },
+            amount: { type: DB.DECIMAL() }
+        };
+        const filters = defaultFilters(schema);
+        const mockEvent = {
+            queryStringParameters: {
+                token: '{"cardHolderName":"Test"}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, filters);
+
+        // Assert — token should not be a direct key (no Op.contains)
+        expect(where.token).not.toBeDefined();
+        // Should produce a case-insensitive jsonb_extract_path_text condition
+        expect(where[DB.Op.and]).toBeDefined();
+        const condition = where[DB.Op.and][0];
+        expect(condition.attribute.fn).toBe('LOWER');
+        const innerFn = condition.attribute.args[0];
+        expect(innerFn.fn).toBe('jsonb_extract_path_text');
+        expect(innerFn.args[0].col).toBe('token');
+        expect(innerFn.args[1]).toBe('cardHolderName');
+        expect(condition.logic[DB.Op.like]).toBe('%test%');
+    });
+
+    it('should case-insensitive search a JSONB field using dot-notation query param', function () {
+        // Arrange
+        const schema = {
+            token: { type: DB.JSONB(), defaultValue: {} }
+        };
+        const filters = defaultFilters(schema);
+        const mockEvent = {
+            queryStringParameters: {
+                'token.lastFour': '8473'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, filters);
+
+        // Assert
+        expect(where.token).not.toBeDefined();
+        expect(where[DB.Op.and]).toBeDefined();
+        const condition = where[DB.Op.and][0];
+        const innerFn = condition.attribute.args[0];
+        expect(innerFn.fn).toBe('jsonb_extract_path_text');
+        expect(innerFn.args[0].col).toBe('token');
+        expect(innerFn.args[1]).toBe('lastFour');
+        expect(condition.logic[DB.Op.like]).toBe('%8473%');
+    });
+
+    it('should handle multiple JSONB columns in the same schema', function () {
+        // Arrange — mirrors payment schema with token and paymentProviderData
+        const schema = {
+            token: { type: DB.JSONB(), defaultValue: {} },
+            paymentProviderData: { type: DB.JSONB() }
+        };
+        const filters = defaultFilters(schema);
+        const mockEvent = {
+            queryStringParameters: {
+                'token.cardHolderName': 'Gregory',
+                'paymentProviderData.payment.result.message': 'APPROVED'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, filters);
+
+        // Assert
+        expect(where.token).not.toBeDefined();
+        expect(where.paymentProviderData).not.toBeDefined();
+        expect(where[DB.Op.and].length).toBe(2);
+        const tokenCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.args?.[0]?.col === 'token');
+        expect(tokenCondition).toBeDefined();
+        expect(tokenCondition.logic[DB.Op.like]).toBe('%gregory%');
+        const providerCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.args?.[0]?.col === 'paymentProviderData');
+        expect(providerCondition).toBeDefined();
+        expect(providerCondition.logic[DB.Op.like]).toBe('%approved%');
+    });
+
+    it('should combine JSONB filters with non-JSONB filters from the same schema', function () {
+        // Arrange
+        const schema = {
+            token: { type: DB.JSONB(), defaultValue: {} },
+            amount: { type: DB.DECIMAL() },
+            status: { type: DB.STRING(20) }
+        };
+        const filters = defaultFilters(schema);
+        const mockEvent = {
+            queryStringParameters: {
+                token: '{"cardType":"Mastercard"}',
+                amount: '100',
+                status: 'Complete'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, filters);
+
+        // Assert — amount uses Op.or (DECIMAL), status uses LOWER+LIKE (STRING)
+        expect(where.amount).toEqual({ [DB.Op.or]: [-100, 100] });
+        expect(where.token).not.toBeDefined();
+        // Op.and should contain both the string condition (status) and the JSONB condition (token)
+        expect(where[DB.Op.and]).toBeDefined();
+        const statusCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.col === 'status');
+        expect(statusCondition).toBeDefined();
+        expect(statusCondition.logic[DB.Op.like]).toBe('%complete%');
+        const jsonbCondition = where[DB.Op.and].find(c => c.attribute?.args?.[0]?.fn === 'jsonb_extract_path_text');
+        expect(jsonbCondition).toBeDefined();
+        expect(jsonbCondition.logic[DB.Op.like]).toBe('%mastercard%');
+    });
+
+    it('should handle JSONB type passed as class reference instead of instance', function () {
+        // Arrange — real schemas like payment.js use db.JSONB (class) not db.JSONB() (instance)
+        const schema = {
+            token: { type: DB.JSONB, defaultValue: {} }
+        };
+        const filters = defaultFilters(schema);
+        const mockEvent = {
+            queryStringParameters: {
+                token: '{"cardHolderName":"Test"}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, filters);
+
+        // Assert — should work the same as the instance form
+        expect(where.token).not.toBeDefined();
+        expect(where[DB.Op.and]).toBeDefined();
+        const condition = where[DB.Op.and][0];
+        expect(condition.attribute.fn).toBe('LOWER');
+        expect(condition.logic[DB.Op.like]).toBe('%test%');
+    });
+
+    it('should handle numeric values in a JSON object query param', function () {
+        // Arrange — e.g. ?token={"firstSix":123456}
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+        const mockEvent = {
+            queryStringParameters: {
+                token: '{"firstSix":123456}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert — number should be stringified correctly
+        expect(where[DB.Op.and]).toBeDefined();
+        expect(where[DB.Op.and].length).toBe(1);
+        const condition = where[DB.Op.and][0];
+        const innerFn = condition.attribute.args[0];
+        expect(innerFn.fn).toBe('jsonb_extract_path_text');
+        expect(innerFn.args[1]).toBe('firstSix');
+        expect(condition.logic[DB.Op.like]).toBe('%123456%');
+    });
+
+    it('should recursively flatten nested objects into deeper jsonb_extract_path_text paths', function () {
+        // Arrange — e.g. ?paymentProviderData={"payment":{"result":{"message":"Approved"}}}
+        const mockFilter = {
+            paymentProviderData: { type: 'jsonb', field: 'paymentProviderData' }
+        };
+        const mockEvent = {
+            queryStringParameters: {
+                paymentProviderData: '{"payment":{"result":{"message":"Approved"}}}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert — should flatten to jsonb_extract_path_text("paymentProviderData", 'payment', 'result', 'message')
+        expect(where[DB.Op.and]).toBeDefined();
+        expect(where[DB.Op.and].length).toBe(1);
+        const condition = where[DB.Op.and][0];
+        const innerFn = condition.attribute.args[0];
+        expect(innerFn.fn).toBe('jsonb_extract_path_text');
+        expect(innerFn.args[0].col).toBe('paymentProviderData');
+        expect(innerFn.args[1]).toBe('payment');
+        expect(innerFn.args[2]).toBe('result');
+        expect(innerFn.args[3]).toBe('message');
+        expect(condition.logic[DB.Op.like]).toBe('%approved%');
+    });
+
+    it('should skip null and array values in a JSON object query param', function () {
+        // Arrange — null and array values should be ignored
+        const mockFilter = {
+            token: { type: 'jsonb', field: 'token' }
+        };
+        const mockEvent = {
+            queryStringParameters: {
+                token: '{"cardHolderName":"Test","tags":["a","b"],"removed":null}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert — only cardHolderName should produce a condition
+        expect(where[DB.Op.and]).toBeDefined();
+        expect(where[DB.Op.and].length).toBe(1);
+        expect(where[DB.Op.and][0].logic[DB.Op.like]).toBe('%test%');
+    });
+
+    it('should handle a mix of nested and primitive values in a JSON object', function () {
+        // Arrange — e.g. ?data={"status":"active","meta":{"region":"US"}}
+        const mockFilter = {
+            data: { type: 'jsonb', field: 'data' }
+        };
+        const mockEvent = {
+            queryStringParameters: {
+                data: '{"status":"active","meta":{"region":"US"}}'
+            },
+            requestContext: {
+                authorizer: {
+                    claims: {
+                        'custom:AR': '{"businessIds":{"1":"A"}}'
+                    }
+                }
+            }
+        };
+
+        // Act
+        const where = createFilters(mockEvent, mockFilter);
+
+        // Assert — should produce two conditions: one flat, one nested
+        expect(where[DB.Op.and]).toBeDefined();
+        expect(where[DB.Op.and].length).toBe(2);
+        const statusCondition = where[DB.Op.and].find(c => c.logic[DB.Op.like] === '%active%');
+        expect(statusCondition).toBeDefined();
+        expect(statusCondition.attribute.args[0].args[1]).toBe('status');
+        const regionCondition = where[DB.Op.and].find(c => c.logic[DB.Op.like] === '%us%');
+        expect(regionCondition).toBeDefined();
+        expect(regionCondition.attribute.args[0].args[1]).toBe('meta');
+        expect(regionCondition.attribute.args[0].args[2]).toBe('region');
+    });
+});