fix(sequelize): add type coercion for booleans in the Where filter

Cast entity columns with type "boolean" from strings to boolean values
in the Loopback 4 Where Filter to Sequelize operation translation layer.

Signed-off-by: KalleV <[email protected]>

Author: KalleV

extensions/sequelize/src/__tests__/integration/repository.integration.ts

@@ -280,6 +280,73 @@ describe('Sequelize CRUD Repository (integration)', () => {
       ]);
     });
 
+    it('creates an entity and finds it using Where filter boolean conditions', async () => {
+      const user = getDummyUser();
+
+      await client.post('/users').send(user);
+
+      const expectedUser = {
+        id: 1,
+        ..._.omit(user, ['password']),
+      };
+
+      const userResponse1 = await client
+        .get('/users')
+        .query({
+          filter: {
+            where: {
+              active: true,
+            },
+          },
+        })
+        .send();
+
+      expect(userResponse1.body).deepEqual([expectedUser]);
+
+      const userResponse2 = await client
+        .get('/users')
+        .query({
+          filter: {
+            where: {
+              active: false,
+            },
+          },
+        })
+        .send();
+
+      expect(userResponse2.body).deepEqual([]);
+
+      const userResponse3 = await client
+        .get('/users')
+        .query({
+          filter: {
+            where: {
+              active: {
+                eq: true,
+              },
+            },
+          },
+        })
+        .send();
+
+      expect(userResponse3.body).deepEqual([expectedUser]);
+
+      const userResponse4 = await client
+        .get('/users')
+        .query({
+          filter: {
+            where: {
+              active: {
+                eq: false,
+              },
+            },
+          },
+        })
+        .send();
+
+      expect(userResponse4.body).deepEqual([]);
+    });
+
     it('counts created entities', async () => {
       await client.post('/users').send(getDummyUser());
       const getResponse = await client.get('/users/count').send();

extensions/sequelize/src/sequelize/sequelize.repository.base.ts

@@ -62,7 +62,7 @@ import {MakeNullishOptional} from 'sequelize/types/utils';
 import {operatorTranslations} from './operator-translation';
 import {SequelizeDataSource} from './sequelize.datasource.base';
 import {SequelizeModel} from './sequelize.model';
-import {isTruelyObject} from './utils';
+import {castToBoolean, isTruelyObject} from './utils';
 
 const debug = debugFactory('loopback:sequelize:repository');
 const debugModelBuilder = debugFactory('loopback:sequelize:modelbuilder');
@@ -646,15 +646,27 @@ export class SequelizeCrudRepository<
         continue;
       }
 
+      const entityClassCol = this.entityClass.definition.properties[columnName];
+      const isBooleanColumn =
+        entityClassCol && entityClassCol.type === 'boolean';
+
       if (isTruelyObject(conditionValue)) {
         sequelizeWhere[columnName] = {};
 
         for (const lb4Operator of Object.keys(<Object>conditionValue)) {
           const sequelizeOperator = this.getSequelizeOperator(
             lb4Operator as keyof typeof operatorTranslations,
           );
-          sequelizeWhere[columnName][sequelizeOperator] =
-            conditionValue![lb4Operator as keyof typeof conditionValue];
+
+          if (isBooleanColumn) {
+            // Handles boolean column conditions like `{ neq: true }` or `{ eq: false }`
+            sequelizeWhere[columnName][sequelizeOperator] = castToBoolean(
+              conditionValue![lb4Operator as keyof typeof conditionValue],
+            );
+          } else {
+            sequelizeWhere[columnName][sequelizeOperator] =
+              conditionValue![lb4Operator as keyof typeof conditionValue];
+          }
         }
       } else if (
         ['and', 'or'].includes(columnName) &&
@@ -673,9 +685,12 @@ export class SequelizeCrudRepository<
           [sequelizeOperator]: conditions,
         });
       } else {
-        // Equals
+        // Equals operation. Casting boolean columns to avoid passing strings as boolean values
+        // to the Sequelize query builders.
         sequelizeWhere[columnName] = {
-          [Op.eq]: conditionValue,
+          [Op.eq]: isBooleanColumn
+            ? castToBoolean(conditionValue)
+            : conditionValue,
         };
       }
     }

extensions/sequelize/src/sequelize/utils.ts

@@ -11,3 +11,21 @@
 export const isTruelyObject = (value?: unknown) => {
   return typeof value === 'object' && !Array.isArray(value) && value !== null;
 };
+
+/**
+ * Coerces a value to a boolean. This is used for Where Filter type coercion
+ * to avoid passing "true" or "false" as strings to the internal Sequelize queries.
+ *
+ * @param value - The value to be serialized.
+ * @returns The coerced boolean value: true / false.
+ */
+export const castToBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') {
+    return value;
+  } else if (typeof value === 'string') {
+    return value.toLowerCase() === 'true';
+  } else {
+    // e.g. null, undefined, 0, 1, etc.
+    return Boolean(value);
+  }
+};