🎩 Implementing Complex Filters in Reactive Model Disrupts Pagination and IndexedDB Query Logic

[veD-tnayrB]

Implementing Complex Filters in Reactive Model Disrupts Pagination and IndexedDB Query Logic

Hello Reactive Model Team 🤙

I've encountered an issue while trying to enhance the client-side Reactive Model with additional filter functionalities,
specifically aiming to integrate complex filters like OR, between, startsWith, etc., while preserving the existing
pagination and filtering features.

Issue Description:

• Functionality Added: An implementation to handle OR operations in filters:

  #processOr = async (params: Record<string, any>[]) => {
  	let items = [];
  	for (let index = 0; index < params.length; index++) {
  		const query = params[index];
  		const response = await this.#parent.store.where(query).toArray();
  		items = [...items, ...response];
  	}
  	return items;
  };

This function successfully handles filters using the OR operator. However, it requires multiple Dexie queries, which
diverges from the original functionality that uses a single IndexedDB request for pagination.

• File Location: library\modules\entities\collection\local-provider\loader.ts

• Original Functionality for Comparison:

  where = (params, limit) => {
  	// ... Previous code
  	const collection = Object.keys(specs).length === 0 ? store : (store.where(specs) as unknown);
  	let query = collection as Collection;
  
  	this.#currentLimit = limit;
  	this.#currentOffset = offset;
  
  	if (sortBy) await query.sortBy(sortBy);
  	query = query.filter(i => i.isDeleted !== 1);
  	const values = await query.offset(offset).limit(limit).toArray();
  	return values;
  };

The challenge is integrating this new OR filter logic without disrupting the existing pagination strategy, which is
reliant on a single IndexedDB request. The current approach of handling multiple Dexie queries for complex filters like
OR, between, startsWith, etc., significantly alters the pagination logic, leading to potential incompatibilities and
errors.

Additional Context:

• This issue is not limited to the OR operator. Similar challenges arise with other Dexie use cases like between,
  startsWith, below, and above.
• Dexie Documentation for Reference:
  • OR: Dexie Collection.or()
  • Other examples: between, startsWith, below, above

Seeking Guidance:

• How can we implement these complex filters while maintaining efficient and consistent pagination?
• Are there any recommended approaches or patterns for handling multiple Dexie queries in a way that aligns with the
  existing pagination logic?

I appreciate any insights or suggestions you might have on this matter.

Best regards, Bryant Caballero