fix: adjust orWhere

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/database",
-  "version": "5.44.0",
+  "version": "5.46.0",
   "description": "The Athenna database handler for SQL/NoSQL.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

src/database/drivers/BaseKnexDriver.ts

@@ -1351,6 +1351,12 @@ export class BaseKnexDriver extends Driver<Knex, Knex.QueryBuilder> {
         throw new EmptyColumnException('orWhere')
       }
 
+      if (this.isUsingJsonSelector(statement)) {
+        this.orWhereJson(statement, operation)
+
+        return this
+      }
+
       this.qb.orWhere(statement, operation)
 
       return this
@@ -1364,6 +1370,12 @@ export class BaseKnexDriver extends Driver<Knex, Knex.QueryBuilder> {
       throw new EmptyValueException('orWhere')
     }
 
+    if (this.isUsingJsonSelector(statement)) {
+      this.orWhereJson(statement, operation, value)
+
+      return this
+    }
+
     this.qb.orWhere(statement, operation, value)
 
     return this

src/database/drivers/PostgresDriver.ts

@@ -176,10 +176,6 @@ export class PostgresDriver extends BaseKnexDriver {
       throw new Error(`Invalid JSON selector: ${column}`)
     }
 
-    if (!parsed.path.includes('*')) {
-      return super.whereJson(column, operator, value)
-    }
-
     const path = this.parseJsonSelectorToWildcardPath(parsed.path)
     const normalized = this.normalizeJsonOperation(operator, value)
 
@@ -209,10 +205,6 @@ export class PostgresDriver extends BaseKnexDriver {
       throw new Error(`Invalid JSON selector: ${column}`)
     }
 
-    if (!parsed.path.includes('*')) {
-      return super.orWhereJson(column, operator, value)
-    }
-
     const path = this.parseJsonSelectorToWildcardPath(parsed.path)
     const normalized = this.normalizeJsonOperation(operator, value)
 

src/models/builders/ModelQueryBuilder.ts

@@ -502,20 +502,12 @@ export class ModelQueryBuilder<
   }
 
   /**
-   * Retrieve values that are soft deleted in database.
+   * Retrieve active and soft deleted values from database.
    */
   public withTrashed() {
     this.isSoftDelete = false
 
-    if (!this.DELETED_AT_PROP) {
-      return this
-    }
-
-    if (this.schema.getModelDriverName() === 'mongo') {
-      this.orWhereNull(this.DELETED_AT_PROP)
-    }
-
-    return this.orWhereNotNull(this.DELETED_AT_PROP)
+    return this
   }
 
   /**

tests/unit/drivers/PostgresDriverTest.ts

@@ -1829,6 +1829,18 @@ export default class PostgresDriverTest {
     assert.deepEqual(data, [{ user_id: '2' }, { user_id: '2' }])
   }
 
+  @Test()
+  public async shouldBeAbleToFilterJsonByKeyUsingWhereSelector({ assert }: Context) {
+    await this.driver.table('events').createMany([
+      { id: '1', metadata: { name: 'admin' } },
+      { id: '2', metadata: { name: 'member' } }
+    ])
+
+    const data = await this.driver.table('events').where('metadata->name', 'admin').findMany()
+
+    assert.deepEqual(data, [{ id: '1', metadata: { name: 'admin' } }])
+  }
+
   @Test()
   public async shouldBeAbleToFilterJsonArrayByIndexUsingWhereJson({ assert }: Context) {
     await this.driver.table('events').createMany([
@@ -2257,6 +2269,18 @@ export default class PostgresDriverTest {
     ])
   }
 
+  @Test()
+  public async shouldBeAbleToFilterJsonUsingOrWhereSelector({ assert }: Context) {
+    await this.driver.table('events').createMany([
+      { id: '1', metadata: { name: 'admin' } },
+      { id: '2', metadata: { name: 'member' } }
+    ])
+
+    const data = await this.driver.table('events').where('id', '0').orWhere('metadata->name', 'member').findMany()
+
+    assert.deepEqual(data, [{ id: '2', metadata: { name: 'member' } }])
+  }
+
   @Test()
   public async shouldBeAbleToAddAOrWhereClauseToTheQueryUsingDriver({ assert }: Context) {
     await this.driver.table('users').createMany([

tests/unit/models/builders/ModelQueryBuilderTest.ts

@@ -1020,14 +1020,18 @@ export default class ModelQueryBuilderTest {
   }
 
   @Test()
-  public async shouldBeAbleToGetSoftDeletedData({ assert }: Context) {
+  public async shouldBeAbleToGetActiveAndSoftDeletedDataWithoutAddingExtraOrClauses({ assert }: Context) {
+    Mock.when(Database.driver, 'whereNull').resolve(undefined)
+    Mock.when(Database.driver, 'orWhereNull').resolve(undefined)
     Mock.when(Database.driver, 'orWhereNotNull').resolve(undefined)
     Mock.when(Database.driver, 'find').resolve({ id: '1' })
 
     const result = await User.query().withTrashed().find()
 
     assert.instanceOf(result, User)
-    assert.calledOnceWith(Database.driver.orWhereNotNull, 'deletedAt')
+    assert.notCalled(Database.driver.whereNull)
+    assert.notCalled(Database.driver.orWhereNull)
+    assert.notCalled(Database.driver.orWhereNotNull)
   }
 
   @Test()