Function createEntityQuery

core/query.ts:90–300

(
  // Might be plain array or any observable array. This allows creating nested queries of previously created queries
  // It is getter as source value might be computed value, so we want to observe getting it (especially in nested queries)
  getSource: () => MaybeObservableArray<Entity<Data, View>>,
  queryConfig: EntityQueryConfig<Data, View>,
  store: EntityStore<Data, View>
)

 * It is also lazy - it will not calculate results until they are needed.
 */
export function createEntityQuery<Data, View>(
  // Might be plain array or any observable array. This allows creating nested queries of previously created queries
  // It is getter as source value might be computed value, so we want to observe getting it (especially in nested queries)
  getSource: () => MaybeObservableArray<Entity<Data, View>>,
  queryConfig: EntityQueryConfig<Data, View>,
  store: EntityStore<Data, View>
): Collection<Data, View> {
  const { definition } = store;
  const { filter, sort, name: queryName } = queryConfig;

  const {
    config: { functionalFilterCheck },
  } = definition;

  if (!filter && !sort) {
    throw new Error(
      `Either filter or sort is needed to be provided to query. If no sort or filter is needed, use .all property.`
    );
  }

  const sortConfig = resolveSortInput(sort);

  function getQueryKeyBase() {
    const parts: string[] = [definition.config.name];

    if (queryName) {
      parts.push(queryName);
    }

    if (filter) {
      if (typeof filter === "function") {
        parts.push(`filter()`);
      } else {
        parts.push(`filter({${Object.keys(filter).join(",")}})`);
      }
    }

    if (sortConfig) {
      parts.push(`sort()[${sortConfig.direction}]`);
    }

    return parts.join("__");
  }

  const queryKeyBase = getQueryKeyBase();

  /**
   * Create filter cache only for functional filter.
   *
   * Simple query filter eg { user_id: "foo" } does not require it as simpleQuery is already cached
   * and observable.
   *
   * Also it is very often used resulting easily in 100k+ calls on production data (we really dont want so many cached functions
   * created for already cached list)
   */
  const cachedFilterForFunctionalFilter =
    typeof filter === "function"
      ? /**