withCount @beforeFetch

[DealerUp]

Hi.

I implemented softDeletes using the example shown here (@Obapelumi):
#1791 (reply in thread)

Everything works perfectly fine! But the withCount method is not applying softDeletes hooks.
SoftDeletes.ts [Trait]

export const softDeleteQuery = (query: ModelQueryBuilderContract<typeof BaseModel>) => {
  const table = query.model.table
  query.whereNull(`${table}.deleted_at`)
}

Order.ts [Model]

@hasMany(() => OrderItem)
public items: HasMany<typeof OrderItem>

OrderItem.ts [Model]

@beforeFetch()
public static softDeletesFetch = softDeleteQuery

OrdersController.ts [Controller]

const order = await Order.query()
    .withCount('items', (query) => {
        query.sum('total_price').as('itemsAmount')
    })

I reviewed the code of the withCount method (@adonisjs/lucid/build/src/Orm/QueryBuilder/index.js) and after a lot of fighting, I applied a "solution" made in Brazil ;-).

The solution (before run select):

/**
 * Apply model hooks
 */
const applyHooks = async () => {
    await subQuery.model.$hooks.exec('before', 'fetch', subQuery);
}

applyHooks();

Is it possible and feasible to add this solution?
Is my analysis correct that I should apply hooks in this scenario?

Tks 4 all

[DealerUp]

@thetutlage any idea?

[thetutlage]

Hooks are not the way to go here. We will have proper support for global scopes, which serve the use case of softDeletes.

[DealerUp]

When will there be adequate support? Do you have any predictions?

[Obapelumi]

I've switched to using normal query scopes for my soft delete use cases because it is more flexible.
Depending on your use case you may not need global scopes. For example, if you decide to implement a restore delete feature then you could do:

export const softDeleteQuery = (
  query: ModelQueryBuilderContract<LucidModel>,
  isDeleted = true
) => {
  const column = `${query.model.table}.deleted_at`
  if (isDeleted) {
    query.whereNotNull(column)
  } else {
    query.whereNull(column)
  }
}

In your model

  public static deleted = scope(softDeleteQuery)

This way you can apply the scope to fetch either deleted or not deleted rows like so:

// not deleted
query.apply(scopes => scopes.deleted(false))

// deleted
query.apply(scopes => scopes.deleted())